fix(process): settle Windows supervisor waits from exit state

Author: obviyus

src/process/supervisor/adapters/child.test.ts

@@ -25,12 +25,19 @@ function createStubChild(pid = 1234) {
   child.stderr = new PassThrough() as ChildProcess["stderr"];
   Object.defineProperty(child, "pid", { value: pid, configurable: true });
   Object.defineProperty(child, "killed", { value: false, configurable: true, writable: true });
+  Object.defineProperty(child, "exitCode", { value: null, configurable: true, writable: true });
+  Object.defineProperty(child, "signalCode", { value: null, configurable: true, writable: true });
   const killMock = vi.fn(() => true);
   child.kill = killMock as ChildProcess["kill"];
   const emitClose = (code: number | null, signal: NodeJS.Signals | null = null) => {
     child.emit("close", code, signal);
   };
-  return { child, killMock, emitClose };
+  const emitExit = (code: number | null, signal: NodeJS.Signals | null = null) => {
+    child.exitCode = code;
+    child.signalCode = signal;
+    child.emit("exit", code, signal);
+  };
+  return { child, killMock, emitClose, emitExit };
 }
 
 async function createAdapterHarness(params?: {
@@ -53,6 +60,14 @@ async function createAdapterHarness(params?: {
 
 describe("createChildAdapter", () => {
   const originalServiceMarker = process.env.OPENCLAW_SERVICE_MARKER;
+  const originalPlatformDescriptor = Object.getOwnPropertyDescriptor(process, "platform");
+
+  const setPlatform = (platform: NodeJS.Platform) => {
+    Object.defineProperty(process, "platform", {
+      configurable: true,
+      value: platform,
+    });
+  };
 
   beforeAll(async () => {
     ({ createChildAdapter } = await import("./child.js"));
@@ -74,6 +89,9 @@ describe("createChildAdapter", () => {
   });
 
   afterEach(() => {
+    if (originalPlatformDescriptor) {
+      Object.defineProperty(process, "platform", originalPlatformDescriptor);
+    }
     vi.useRealTimers();
   });
 
@@ -155,6 +173,34 @@ describe("createChildAdapter", () => {
     expect(killMock).toHaveBeenCalledWith("SIGKILL");
   });
 
+  it("settles wait from exit state on Windows even when close never arrives", async () => {
+    vi.useFakeTimers();
+    setPlatform("win32");
+
+    const { adapter, emitExit } = await (async () => {
+      const stub = createStubChild(8642);
+      spawnWithFallbackMock.mockResolvedValue({
+        child: stub.child,
+        usedFallback: false,
+      });
+      const adapter = await createChildAdapter({
+        argv: ["openclaw", "version"],
+        stdinMode: "pipe-closed",
+      });
+      return { ...stub, adapter };
+    })();
+
+    const settled = vi.fn();
+    void adapter.wait().then((result) => {
+      settled(result);
+    });
+
+    emitExit(0, null);
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(settled).toHaveBeenCalledWith({ code: 0, signal: null });
+  });
+
   it("disables detached mode in service-managed runtime", async () => {
     process.env.OPENCLAW_SERVICE_MARKER = "openclaw";
 

src/process/supervisor/adapters/child.ts

@@ -6,6 +6,8 @@ import type { ManagedRunStdin, SpawnProcessAdapter } from "../types.js";
 import { toStringEnv } from "./env.js";
 
 const FORCE_KILL_WAIT_FALLBACK_MS = 4000;
+const WINDOWS_CLOSE_STATE_SETTLE_TIMEOUT_MS = 250;
+const WINDOWS_CLOSE_STATE_POLL_MS = 10;
 
 function resolveCommand(command: string): string {
   return resolveWindowsCommandShim({
@@ -122,6 +124,8 @@ export async function createChildAdapter(params: {
   let rejectWait: ((reason?: unknown) => void) | null = null;
   let waitPromise: Promise<{ code: number | null; signal: NodeJS.Signals | null }> | null = null;
   let forceKillWaitFallbackTimer: NodeJS.Timeout | null = null;
+  let childExitState: { code: number | null; signal: NodeJS.Signals | null } | null = null;
+  let windowsExitSettleTimer: NodeJS.Timeout | null = null;
 
   const clearForceKillWaitFallback = () => {
     if (!forceKillWaitFallbackTimer) {
@@ -131,11 +135,20 @@ export async function createChildAdapter(params: {
     forceKillWaitFallbackTimer = null;
   };
 
+  const clearWindowsExitSettleTimer = () => {
+    if (!windowsExitSettleTimer) {
+      return;
+    }
+    clearTimeout(windowsExitSettleTimer);
+    windowsExitSettleTimer = null;
+  };
+
   const settleWait = (value: { code: number | null; signal: NodeJS.Signals | null }) => {
     if (waitResult || waitError !== undefined) {
       return;
     }
     clearForceKillWaitFallback();
+    clearWindowsExitSettleTimer();
     waitResult = value;
     if (resolveWait) {
       const resolve = resolveWait;
@@ -150,6 +163,7 @@ export async function createChildAdapter(params: {
       return;
     }
     clearForceKillWaitFallback();
+    clearWindowsExitSettleTimer();
     waitError = error;
     if (rejectWait) {
       const reject = rejectWait;
@@ -168,11 +182,60 @@ export async function createChildAdapter(params: {
     forceKillWaitFallbackTimer.unref?.();
   };
 
+  const resolveObservedExitState = (fallback: {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+  }) => ({
+    code: childExitState?.code ?? child.exitCode ?? fallback.code,
+    signal: childExitState?.signal ?? child.signalCode ?? fallback.signal,
+  });
+
+  const hasObservedExitState = () =>
+    childExitState != null || child.exitCode != null || child.signalCode != null;
+
+  const scheduleWindowsExitStateSettle = (fallback: {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+  }) => {
+    if (process.platform !== "win32") {
+      return;
+    }
+    clearWindowsExitSettleTimer();
+    windowsExitSettleTimer = setTimeout(() => {
+      settleWait(resolveObservedExitState(fallback));
+    }, WINDOWS_CLOSE_STATE_SETTLE_TIMEOUT_MS);
+  };
+
   child.once("error", (error) => {
     rejectPendingWait(error);
   });
+  child.once("exit", (code, signal) => {
+    childExitState = { code, signal };
+    scheduleWindowsExitStateSettle({ code, signal });
+  });
   child.once("close", (code, signal) => {
-    settleWait({ code, signal });
+    if (process.platform !== "win32" || hasObservedExitState() || code != null || signal != null) {
+      settleWait(resolveObservedExitState({ code, signal }));
+      return;
+    }
+
+    const startedAt = Date.now();
+    const waitForExitState = () => {
+      if (waitResult || waitError !== undefined) {
+        return;
+      }
+      if (hasObservedExitState()) {
+        settleWait(resolveObservedExitState({ code, signal }));
+        return;
+      }
+      if (Date.now() - startedAt >= WINDOWS_CLOSE_STATE_SETTLE_TIMEOUT_MS) {
+        settleWait({ code, signal });
+        return;
+      }
+      setTimeout(waitForExitState, WINDOWS_CLOSE_STATE_POLL_MS);
+    };
+
+    waitForExitState();
   });
 
   const wait = async () => {
@@ -229,6 +292,7 @@ export async function createChildAdapter(params: {
 
   const dispose = () => {
     clearForceKillWaitFallback();
+    clearWindowsExitSettleTimer();
     child.removeAllListeners();
   };