fix: propagate AbortSignal on cancellation to stop iOS runner promptly (#194)

* fix: propagate AbortSignal on request cancellation to stop iOS runner promptly

When a client disconnects (socket close or HTTP connection drop), in-flight
iOS runner operations now receive an AbortSignal that immediately interrupts
pending HTTP fetches, retry delays, and retry loops—ensuring detached
xcodebuild/runner processes are not driven after the parent workflow is canceled.

Closes #193

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: ensure HTTP disconnect cancellation always propagates

* fix: rethrow canceled runner waits before fallback

* fix: harden cancellation tracking and propagation

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: thymikee

src/daemon.ts

@@ -20,7 +20,14 @@ import { handleLeaseCommands } from './daemon/handlers/lease.ts';
 import { cleanupStaleAppLogProcesses } from './daemon/app-log.ts';
 import { assertSessionSelectorMatches } from './daemon/session-selector.ts';
 import { resolveEffectiveSessionName } from './daemon/session-routing.ts';
-import { clearRequestCanceled, isRequestCanceled, markRequestCanceled } from './daemon/request-cancel.ts';
+import {
+  clearRequestCanceled,
+  createRequestCanceledError,
+  isRequestCanceled,
+  markRequestCanceled,
+  registerRequestAbort,
+  resolveRequestTrackingId,
+} from './daemon/request-cancel.ts';
 import {
   isAgentDeviceDaemonProcess,
   readProcessStartTime,
@@ -437,12 +444,15 @@ function createSocketServer(): net.Server {
         let requestIdForCleanup: string | undefined;
         try {
           const req = JSON.parse(line) as DaemonRequest;
-          requestIdForCleanup = req.meta?.requestId;
-          if (requestIdForCleanup) {
-            activeRequestIds.add(requestIdForCleanup);
-            if (isRequestCanceled(requestIdForCleanup)) {
-              throw new AppError('COMMAND_FAILED', 'request canceled');
-            }
+          requestIdForCleanup = resolveRequestTrackingId(req.meta?.requestId, 'socket');
+          req.meta = {
+            ...req.meta,
+            requestId: requestIdForCleanup,
+          };
+          activeRequestIds.add(requestIdForCleanup);
+          registerRequestAbort(requestIdForCleanup);
+          if (isRequestCanceled(requestIdForCleanup)) {
+            throw createRequestCanceledError();
           }
           response = await handleRequest(req);
         } catch (err) {

src/daemon/__tests__/request-cancel.test.ts

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { AppError } from '../../utils/errors.ts';
+import {
+  createRequestCanceledError,
+  isRequestCanceledError,
+  resolveRequestTrackingId,
+} from '../request-cancel.ts';
+
+test('resolveRequestTrackingId keeps explicit request id', () => {
+  assert.equal(resolveRequestTrackingId('req-123'), 'req-123');
+});
+
+test('resolveRequestTrackingId generates unique ids for fallback seeds', () => {
+  const first = resolveRequestTrackingId(undefined, 42);
+  const second = resolveRequestTrackingId(undefined, 42);
+  assert.match(first, /^req:42:/);
+  assert.match(second, /^req:42:/);
+  assert.notEqual(first, second);
+});
+
+test('createRequestCanceledError includes stable cancellation reason marker', () => {
+  const err = createRequestCanceledError();
+  assert.equal(err.code, 'COMMAND_FAILED');
+  assert.equal(err.message, 'request canceled');
+  assert.equal(err.details?.reason, 'request_canceled');
+});
+
+test('isRequestCanceledError accepts structured and legacy cancellation errors', () => {
+  assert.equal(isRequestCanceledError(createRequestCanceledError()), true);
+  assert.equal(isRequestCanceledError(new AppError('COMMAND_FAILED', 'request canceled')), true);
+  assert.equal(isRequestCanceledError(new AppError('COMMAND_FAILED', 'different message')), false);
+});

src/daemon/http-server.ts

@@ -2,6 +2,12 @@ import http, { type IncomingHttpHeaders } from 'node:http';
 import { AppError, normalizeError } from '../utils/errors.ts';
 import type { DaemonRequest, DaemonResponse } from './types.ts';
 import { normalizeTenantId } from './config.ts';
+import {
+  clearRequestCanceled,
+  markRequestCanceled,
+  registerRequestAbort,
+  resolveRequestTrackingId,
+} from './request-cancel.ts';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { trackUploadedArtifact } from './upload-registry.ts';
@@ -294,6 +300,7 @@ export async function createDaemonHttpServer(options: {
         return;
       }
 
+      let requestIdForCleanup: string | undefined;
       try {
         const params = rpcRequest.params as Record<string, unknown>;
         const daemonRequest = methodToDaemonRequest(rpcRequest.method, params, req.headers);
@@ -305,6 +312,18 @@ export async function createDaemonHttpServer(options: {
           return;
         }
 
+        requestIdForCleanup = resolveRequestTrackingId(daemonRequest.meta?.requestId, rpcRequest.id);
+        daemonRequest.meta = {
+          ...daemonRequest.meta,
+          requestId: requestIdForCleanup,
+        };
+        registerRequestAbort(requestIdForCleanup);
+        req.on('close', () => {
+          if (!res.writableFinished) {
+            markRequestCanceled(requestIdForCleanup);
+          }
+        });
+
         const authResult = await runHttpAuthHook(authHook, {
           headers: req.headers,
           rpcRequest,
@@ -344,6 +363,8 @@ export async function createDaemonHttpServer(options: {
           createRpcError(rpcRequest.id ?? null, -32000, normalized.message, normalized),
           statusCodeForNormalizedError(normalized.code),
         );
+      } finally {
+        clearRequestCanceled(requestIdForCleanup);
       }
     });
   });

src/daemon/request-cancel.ts

@@ -1,16 +1,60 @@
+import { AppError } from '../utils/errors.ts';
+
 const canceledRequestIds = new Set<string>();
+const requestAbortControllers = new Map<string, AbortController>();
+const REQUEST_CANCELED_REASON = 'request_canceled';
+const REQUEST_CANCELED_MESSAGE = 'request canceled';
+
+export function resolveRequestTrackingId(requestId: string | undefined, fallbackSeed?: unknown): string {
+  if (typeof requestId === 'string' && requestId.length > 0) return requestId;
+  const rawSeed = typeof fallbackSeed === 'string'
+    ? fallbackSeed
+    : (typeof fallbackSeed === 'number' && Number.isFinite(fallbackSeed) ? String(fallbackSeed) : 'generated');
+  const normalizedSeed = rawSeed.trim().replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 32) || 'generated';
+  const nonce = Math.random().toString(36).slice(2, 10);
+  return `req:${normalizedSeed}:${process.pid}:${Date.now()}:${nonce}`;
+}
+
+export function registerRequestAbort(requestId: string | undefined): void {
+  if (!requestId) return;
+  const controller = new AbortController();
+  requestAbortControllers.set(requestId, controller);
+  if (canceledRequestIds.has(requestId)) {
+    controller.abort();
+  }
+}
 
 export function markRequestCanceled(requestId: string | undefined): void {
   if (!requestId) return;
   canceledRequestIds.add(requestId);
+  requestAbortControllers.get(requestId)?.abort();
 }
 
 export function clearRequestCanceled(requestId: string | undefined): void {
   if (!requestId) return;
   canceledRequestIds.delete(requestId);
+  requestAbortControllers.delete(requestId);
 }
 
 export function isRequestCanceled(requestId: string | undefined): boolean {
   if (!requestId) return false;
   return canceledRequestIds.has(requestId);
 }
+
+export function getRequestSignal(requestId: string | undefined): AbortSignal | undefined {
+  if (!requestId) return undefined;
+  return requestAbortControllers.get(requestId)?.signal;
+}
+
+export function createRequestCanceledError(): AppError {
+  return new AppError('COMMAND_FAILED', REQUEST_CANCELED_MESSAGE, {
+    reason: REQUEST_CANCELED_REASON,
+  });
+}
+
+export function isRequestCanceledError(error: unknown): boolean {
+  if (!(error instanceof AppError)) return false;
+  if (error.code !== 'COMMAND_FAILED') return false;
+  if (error.details?.reason === REQUEST_CANCELED_REASON) return true;
+  return error.message === REQUEST_CANCELED_MESSAGE;
+}

src/platforms/ios/__tests__/runner-transport.test.ts

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import type { DeviceInfo } from '../../../utils/device.ts';
+import { AppError } from '../../../utils/errors.ts';
+import { waitForRunner } from '../runner-transport.ts';
+
+const iosSimulator: DeviceInfo = {
+  platform: 'ios',
+  id: 'sim-1',
+  name: 'iPhone Simulator',
+  kind: 'simulator',
+  booted: true,
+};
+
+test('waitForRunner propagates request cancellation without fallback', async () => {
+  const signal = AbortSignal.abort();
+  await assert.rejects(
+    () => waitForRunner(iosSimulator, 8100, { command: 'snapshot' }, undefined, 5_000, undefined, signal),
+    (error: unknown) => {
+      assert.equal(error instanceof AppError, true);
+      const appError = error as AppError;
+      assert.equal(appError.code, 'COMMAND_FAILED');
+      assert.equal(appError.message, 'request canceled');
+      assert.equal(appError.message.includes('Runner did not accept connection'), false);
+      return true;
+    },
+  );
+});

src/platforms/ios/runner-client.ts

@@ -1,6 +1,7 @@
 import { AppError } from '../../utils/errors.ts';
 import { withRetry } from '../../utils/retry.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
+import { getRequestSignal } from '../../daemon/request-cancel.ts';
 import {
   isRetryableRunnerError,
   shouldRetryRunnerConnectError,
@@ -93,6 +94,7 @@ async function executeRunnerCommand(
   options: { verbose?: boolean; logPath?: string; traceLogPath?: string; requestId?: string } = {},
 ): Promise<Record<string, unknown>> {
   assertRunnerRequestActive(options.requestId);
+  const signal = getRequestSignal(options.requestId);
   let session: RunnerSession | undefined;
   try {
     session = await ensureRunnerSession(device, options);
@@ -103,6 +105,7 @@ async function executeRunnerCommand(
       command,
       options.logPath,
       timeoutMs,
+      signal,
     );
   } catch (err) {
     const appErr = err instanceof AppError ? err : new AppError('COMMAND_FAILED', String(err));
@@ -126,6 +129,8 @@ async function executeRunnerCommand(
         command,
         options.logPath,
         RUNNER_STARTUP_TIMEOUT_MS,
+        undefined,
+        signal,
       );
       return await parseRunnerResponse(response, session, options.logPath);
     }

src/platforms/ios/runner-errors.ts

@@ -1,6 +1,6 @@
 import { AppError } from '../../utils/errors.ts';
 import { bootFailureHint, classifyBootFailure } from '../boot-diagnostics.ts';
-import { isRequestCanceled } from '../../daemon/request-cancel.ts';
+import { createRequestCanceledError, isRequestCanceled } from '../../daemon/request-cancel.ts';
 import type { RunnerCommand } from './runner-client.ts';
 import type { RunnerSession } from './runner-session.ts';
 
@@ -109,5 +109,5 @@ export function isReadOnlyRunnerCommand(command: RunnerCommand['command']): bool
 
 export function assertRunnerRequestActive(requestId: string | undefined): void {
   if (!isRequestCanceled(requestId)) return;
-  throw new AppError('COMMAND_FAILED', 'request canceled');
+  throw createRequestCanceledError();
 }

src/platforms/ios/runner-session.ts

@@ -247,8 +247,9 @@ export async function executeRunnerCommandWithSession(
   command: RunnerCommand,
   logPath: string | undefined,
   timeoutMs: number,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-  const response = await waitForRunner(device, session.port, command, logPath, timeoutMs, session);
+  const response = await waitForRunner(device, session.port, command, logPath, timeoutMs, session, signal);
   return await parseRunnerResponse(response, session, logPath);
 }
 

src/platforms/ios/runner-transport.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import net from 'node:net';
+import { createRequestCanceledError, isRequestCanceledError } from '../../daemon/request-cancel.ts';
 import { AppError } from '../../utils/errors.ts';
 import { runCmd } from '../../utils/exec.ts';
 import { Deadline, retryWithPolicy } from '../../utils/retry.ts';
@@ -65,6 +66,7 @@ export async function waitForRunner(
   logPath?: string,
   timeoutMs: number = RUNNER_STARTUP_TIMEOUT_MS,
   session?: RunnerSession,
+  signal?: AbortSignal,
 ): Promise<Response> {
   const deadline = Deadline.fromTimeoutMs(timeoutMs);
   let endpoints = await resolveRunnerCommandEndpoints(device, port, deadline.remainingMs());
@@ -102,9 +104,13 @@ export async function waitForRunner(
                 body: JSON.stringify(command),
               },
               Math.min(RUNNER_CONNECT_REQUEST_TIMEOUT_MS, remainingMs),
+              signal,
             );
             return response;
           } catch (err) {
+            if (signal?.aborted || isRequestCanceledError(err)) {
+              throw createRequestCanceledError();
+            }
             lastError = err;
           }
         }
@@ -121,14 +127,21 @@ export async function waitForRunner(
         jitter: 0.2,
         shouldRetry: shouldRetryRunnerConnectError,
       },
-      { deadline, phase: 'ios_runner_connect' },
+      { deadline, phase: 'ios_runner_connect', signal },
     );
   } catch (error) {
+    if (signal?.aborted || isRequestCanceledError(error)) {
+      throw createRequestCanceledError();
+    }
     if (!lastError) {
       lastError = error;
     }
   }
 
+  if (signal?.aborted) {
+    throw createRequestCanceledError();
+  }
+
   if (device.kind === 'simulator') {
     const remainingMs = deadline.remainingMs();
     if (remainingMs <= 0) {
@@ -161,13 +174,27 @@ async function fetchWithTimeout(
   url: string,
   init: RequestInit,
   timeoutMs: number,
+  requestSignal?: AbortSignal,
 ): Promise<Response> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let onRequestAbort: (() => void) | undefined;
+  if (requestSignal) {
+    if (requestSignal.aborted) {
+      clearTimeout(timeout);
+      controller.abort();
+    } else {
+      onRequestAbort = () => controller.abort();
+      requestSignal.addEventListener('abort', onRequestAbort, { once: true });
+    }
+  }
   try {
     return await fetch(url, { ...init, signal: controller.signal });
   } finally {
     clearTimeout(timeout);
+    if (onRequestAbort && requestSignal) {
+      requestSignal.removeEventListener('abort', onRequestAbort);
+    }
   }
 }
 

src/utils/interactors.ts

@@ -21,7 +21,7 @@ import {
   screenshotIos,
 } from '../platforms/ios/index.ts';
 import { runIosRunnerCommand } from '../platforms/ios/runner-client.ts';
-import { isRequestCanceled } from '../daemon/request-cancel.ts';
+import { createRequestCanceledError, isRequestCanceled } from '../daemon/request-cancel.ts';
 
 export type RunnerContext = {
   requestId?: string;
@@ -95,7 +95,7 @@ function iosRunnerOverrides(device: DeviceInfo, ctx: RunnerContext): IoRunnerOve
   };
   const throwIfCanceled = () => {
     if (!isRequestCanceled(ctx.requestId)) return;
-    throw new AppError('COMMAND_FAILED', 'request canceled');
+    throw createRequestCanceledError();
   };
 
   return {