fix(codex): stabilize app-server release tests

vincentkoc · vincentkoc · commit 8c802aa68351 · 2026-06-12T13:26:29.000+08:00
diff --git a/extensions/codex/src/app-server/attempt-startup.test.ts b/extensions/codex/src/app-server/attempt-startup.test.ts
@@ -177,7 +177,7 @@ describe("startCodexAttemptThread", () => {
     vi.restoreAllMocks();
     vi.unstubAllEnvs();
     for (const root of tempRoots) {
-      await fs.rm(root, { recursive: true, force: true });
+      await fs.rm(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 20 });
     }
     tempRoots.clear();
   });
@@ -240,7 +240,7 @@ describe("startCodexAttemptThread", () => {
   });
 
   it("clears the shared app-server when startup abandons an in-flight thread request", async () => {
-    const { harness, run } = startThreadWithHarness(2_000);
+    const { harness, run } = startThreadWithHarness(250);
     const runError = run.then(
       () => undefined,
       (error: unknown) => error,
diff --git a/extensions/codex/src/app-server/run-attempt.turn-watches.test.ts b/extensions/codex/src/app-server/run-attempt.turn-watches.test.ts
@@ -459,75 +459,61 @@ describe("runCodexAppServerAttempt turn watches", () => {
   });
 
   it("keeps a progressing active turn alive beyond the original attempt timeout", async () => {
-    const harness = createStartedThreadHarness();
-    const params = createParams(
-      path.join(tempDir, "session.jsonl"),
-      path.join(tempDir, "workspace"),
-    );
-    params.timeoutMs = 100;
     const onRunProgress = vi.fn();
-    params.onRunProgress = onRunProgress;
-
-    const run = runCodexAppServerAttempt(params, {
-      turnCompletionIdleTimeoutMs: 300,
-      turnAssistantCompletionIdleTimeoutMs: 300,
-      turnTerminalIdleTimeoutMs: 300,
+    const onTimeout = vi.fn();
+    const onAbort = vi.fn();
+    const controller = createCodexAttemptTurnWatchController({
+      threadId: "thread-1",
+      signal: new AbortController().signal,
+      getTurnId: () => "turn-1",
+      isCompleted: () => false,
+      isTerminalTurnNotificationQueued: () => false,
+      getActiveAppServerTurnRequests: () => 0,
+      getActiveTurnItemCount: () => 0,
+      turnCompletionIdleTimeoutMs: 1_000,
+      turnAssistantCompletionIdleTimeoutMs: 1_000,
+      turnAttemptIdleTimeoutMs: 300,
+      turnTerminalIdleTimeoutMs: 1_000,
+      interruptTimeoutMs: 5_000,
+      onInterruptTurn: vi.fn(),
+      onTimeout,
+      onMarkTimedOut: vi.fn(),
+      onAbort,
+      onCompleted: vi.fn(),
+      onResolveCompletion: vi.fn(),
+      onRecordEvent: vi.fn(),
+      onAttemptProgress: onRunProgress,
+      onProgressDiagnostic: vi.fn(),
     });
-    await harness.waitForMethod("turn/start");
-    await vi.waitFor(
-      () =>
-        expect(onRunProgress).toHaveBeenCalledWith(
-          expect.objectContaining({ reason: "turn:start" }),
-        ),
-      fastWait,
-    );
 
-    await new Promise((resolve) => {
-      setTimeout(resolve, 60);
-    });
-    await harness.notify({
-      method: "rawResponseItem/completed",
-      params: {
-        threadId: "thread-1",
-        turnId: "turn-1",
-        item: {
-          type: "message",
-          id: "raw-progress-1",
-          role: "assistant",
-          content: [{ type: "output_text", text: "Still working." }],
-        },
-      },
-    });
-    await new Promise((resolve) => {
-      setTimeout(resolve, 60);
-    });
-    await harness.notify({
-      method: "rawResponseItem/completed",
-      params: {
-        threadId: "thread-1",
-        turnId: "turn-1",
-        item: {
-          type: "message",
-          id: "raw-progress-2",
-          role: "assistant",
-          content: [{ type: "output_text", text: "Almost done." }],
-        },
-      },
-    });
+    vi.useFakeTimers();
+    try {
+      controller.armAttemptIdleWatch();
+      controller.touchActivity("turn:start", { attemptProgress: true });
 
-    expect(harness.request.mock.calls.some(([method]) => method === "turn/interrupt")).toBe(false);
-    await harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
+      await vi.advanceTimersByTimeAsync(200);
+      controller.noteNotificationReceived("response.custom_tool_call_input.delta", {
+        attemptProgress: true,
+      });
 
-    const result = await run;
-    expect(result.aborted).toBe(false);
-    expect(result.timedOut).toBe(false);
-    expect(result.promptError).toBeNull();
-    expect(harness.request.mock.calls.some(([method]) => method === "turn/interrupt")).toBe(false);
-    const progressReasons = onRunProgress.mock.calls.map(([info]) => info.reason);
-    expect(progressReasons).toContain("turn:start");
-    expect(
-      progressReasons.filter((reason) => reason === "notification:rawResponseItem/completed"),
-    ).toHaveLength(2);
+      await vi.advanceTimersByTimeAsync(200);
+      controller.noteNotificationReceived("response.custom_tool_call_input.delta", {
+        attemptProgress: true,
+      });
+
+      await vi.advanceTimersByTimeAsync(200);
+
+      expect(onTimeout).not.toHaveBeenCalled();
+      expect(onAbort).not.toHaveBeenCalled();
+      expect(onRunProgress.mock.calls.map(([reason]) => reason)).toEqual([
+        "turn:start",
+        "notification:response.custom_tool_call_input.delta",
+        "notification:response.custom_tool_call_input.delta",
+      ]);
+    } finally {
+      controller.clearAllTimers();
+      vi.useRealTimers();
+    }
   });
 
   it("does not count non-turn app-server requests as turn attempt progress", async () => {
