fix(platform-ios): bound simulator log stream shutdown

Author: V3RON

packages/platform-ios/src/__tests__/app-monitor.test.ts

@@ -32,6 +32,18 @@ const createStreamingSubprocess = (
     },
   } as unknown as Subprocess);
 
+const createHangingSubprocess = (kill: () => void): Subprocess =>
+  ({
+    nodeChildProcess: Promise.resolve({
+      kill,
+    }),
+    [Symbol.asyncIterator]() {
+      return {
+        next: () => new Promise(() => undefined),
+      };
+    },
+  } as unknown as Subprocess);
+
 const artifactRoot = fs.mkdtempSync(
   join(tmpdir(), 'rn-harness-ios-monitor-artifacts-')
 );
@@ -128,6 +140,38 @@ describe('createIosSimulatorAppMonitor', () => {
     );
   });
 
+  it('does not hang when simulator log stream does not finish after kill', async () => {
+    vi.useFakeTimers();
+
+    const kill = vi.fn();
+    vi.spyOn(simctl, 'streamLogs').mockReturnValue(createHangingSubprocess(kill));
+    vi.spyOn(simctl, 'getAppInfo').mockResolvedValue({
+      Bundle: 'com.harnessplayground',
+      CFBundleIdentifier: 'com.harnessplayground',
+      CFBundleExecutable: 'HarnessPlayground',
+      CFBundleName: 'HarnessPlayground',
+      CFBundleDisplayName: 'Harness Playground',
+      Path: '/tmp/HarnessPlayground.app',
+    });
+
+    const monitor = createIosSimulatorAppMonitor({
+      udid: 'sim-udid',
+      bundleId: 'com.harnessplayground',
+      isAppRunning: async () => true,
+    });
+
+    try {
+      await monitor.start();
+      const stopPromise = monitor.stop();
+
+      await vi.advanceTimersByTimeAsync(1000);
+      await expect(stopPromise).resolves.toBeUndefined();
+      expect(kill).toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('reports simulator lifecycle and crash events through the reporter', async () => {
     vi.useFakeTimers();
 

packages/platform-ios/src/app-monitor.ts

@@ -32,6 +32,7 @@ const POST_LAUNCH_CRASH_SWEEP_DELAY_MS = 1000;
 const RECENT_LAUNCH_WINDOW_MS = 5000;
 const SUSPICION_WINDOW_MS = 3000;
 const CRASH_ARTIFACT_MIN_OCCURRED_AT_TOLERANCE_MS = 2000;
+const LOG_STREAM_SHUTDOWN_TIMEOUT_MS = 1000;
 
 type TimedLogLine = {
   line: string;
@@ -473,6 +474,58 @@ const waitForPollInterval = async (signal: AbortSignal) => {
   });
 };
 
+const waitForTaskShutdown = async (
+  task: Promise<void> | null,
+  timeoutMs: number,
+  timeoutMessage: string
+) => {
+  if (!task) {
+    return;
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  const timeoutTask = new Promise<'timeout'>((resolve) => {
+    timeout = setTimeout(() => resolve('timeout'), timeoutMs);
+  });
+
+  try {
+    const result = await Promise.race([
+      task.then(
+        () => 'settled' as const,
+        (error) => {
+          iosAppMonitorLogger.debug('iOS monitor task stopped with error', error);
+          return 'settled' as const;
+        }
+      ),
+      timeoutTask,
+    ]);
+
+    if (result === 'timeout') {
+      iosAppMonitorLogger.warn(timeoutMessage);
+    }
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+const stopLogProcess = async (process: Subprocess | null) => {
+  if (!process) {
+    return;
+  }
+
+  try {
+    const childProcess = await process.nodeChildProcess;
+
+    if (!childProcess.killed) {
+      childProcess.kill();
+    }
+  } catch {
+    // Ignore termination failures for background monitors.
+  }
+};
+
 const createProcessExitDetails = ({
   platform,
   processName,
@@ -1063,15 +1116,12 @@ export const createIosSimulatorAppMonitor = ({
       logTask = null;
       pollTask = null;
 
-      if (currentLogProcess) {
-        try {
-          (await currentLogProcess.nodeChildProcess).kill();
-        } catch {
-          // Ignore termination failures for background monitors.
-        }
-      }
-
-      await currentLogTask;
+      await stopLogProcess(currentLogProcess);
+      await waitForTaskShutdown(
+        currentLogTask,
+        LOG_STREAM_SHUTDOWN_TIMEOUT_MS,
+        'iOS simulator log stream did not stop within shutdown timeout; continuing'
+      );
       await currentPollTask;
     },
     dispose: async () => {
@@ -1089,15 +1139,12 @@ export const createIosSimulatorAppMonitor = ({
       logTask = null;
       pollTask = null;
 
-      if (currentLogProcess) {
-        try {
-          (await currentLogProcess.nodeChildProcess).kill();
-        } catch {
-          // Ignore termination failures for background monitors.
-        }
-      }
-
-      await currentLogTask;
+      await stopLogProcess(currentLogProcess);
+      await waitForTaskShutdown(
+        currentLogTask,
+        LOG_STREAM_SHUTDOWN_TIMEOUT_MS,
+        'iOS simulator log stream did not stop within dispose timeout; continuing'
+      );
       await currentPollTask;
     },
     launchRequested: (event) => {