feat(cloud): auto-retry errored cloud streams on window focus (#2188)

Author: joshsny

apps/code/src/renderer/components/GlobalEventHandlers.tsx

@@ -1,6 +1,7 @@
 import { useReviewNavigationStore } from "@features/code-review/stores/reviewNavigationStore";
 import { useFolders } from "@features/folders/hooks/useFolders";
 import { usePanelLayoutStore } from "@features/panels/store/panelLayoutStore";
+import { getSessionService } from "@features/sessions/service/service";
 import { useSettingsDialogStore } from "@features/settings/stores/settingsDialogStore";
 import { useSidebarData } from "@features/sidebar/hooks/useSidebarData";
 import { useVisualTaskOrder } from "@features/sidebar/hooks/useVisualTaskOrder";
@@ -227,6 +228,7 @@ export function GlobalEventHandlers({
   useEffect(() => {
     const handleFocus = () => {
       loadFolders();
+      getSessionService().retryUnhealthyCloudSessions();
     };
     window.addEventListener("focus", handleFocus);
     return () => window.removeEventListener("focus", handleFocus);

apps/code/src/renderer/features/sessions/service/service.test.ts

@@ -2300,6 +2300,120 @@ describe("SessionService", () => {
     });
   });
 
+  describe("retryUnhealthyCloudSessions", () => {
+    it("retries every errored cloud session", async () => {
+      const service = getSessionService();
+
+      const erroredCloudA: AgentSession = {
+        ...createMockSession({
+          taskId: "task-a",
+          taskRunId: "run-a",
+          status: "error",
+        }),
+        isCloud: true,
+      };
+      const erroredCloudB: AgentSession = {
+        ...createMockSession({
+          taskId: "task-b",
+          taskRunId: "run-b",
+          status: "error",
+        }),
+        isCloud: true,
+      };
+
+      mockSessionStoreSetters.getSessions.mockReturnValue({
+        "run-a": erroredCloudA,
+        "run-b": erroredCloudB,
+      });
+      mockSessionStoreSetters.getSessionByTaskId.mockImplementation(
+        (taskId: string) => {
+          if (taskId === "task-a") return erroredCloudA;
+          if (taskId === "task-b") return erroredCloudB;
+          return undefined;
+        },
+      );
+
+      service.retryUnhealthyCloudSessions();
+
+      await vi.waitFor(() => {
+        expect(mockTrpcCloudTask.retry.mutate).toHaveBeenCalledTimes(2);
+      });
+      expect(mockTrpcCloudTask.retry.mutate).toHaveBeenCalledWith({
+        taskId: "task-a",
+        runId: "run-a",
+      });
+      expect(mockTrpcCloudTask.retry.mutate).toHaveBeenCalledWith({
+        taskId: "task-b",
+        runId: "run-b",
+      });
+    });
+
+    it.each([
+      [
+        "non-error cloud session (status=connected)",
+        {
+          ...createMockSession({
+            taskId: "task-skip",
+            taskRunId: "run-skip",
+            status: "connected",
+          }),
+          isCloud: true,
+        } as AgentSession,
+      ],
+      [
+        "non-error cloud session (status=disconnected)",
+        {
+          ...createMockSession({
+            taskId: "task-skip",
+            taskRunId: "run-skip",
+            status: "disconnected",
+          }),
+          isCloud: true,
+        } as AgentSession,
+      ],
+      [
+        "errored local session (isCloud=false)",
+        createMockSession({
+          taskId: "task-skip",
+          taskRunId: "run-skip",
+          status: "error",
+        }),
+      ],
+    ])("skips %s", (_label, session) => {
+      const service = getSessionService();
+      mockSessionStoreSetters.getSessions.mockReturnValue({
+        "run-skip": session,
+      });
+
+      service.retryUnhealthyCloudSessions();
+
+      expect(mockTrpcCloudTask.retry.mutate).not.toHaveBeenCalled();
+    });
+
+    it("swallows failures so one bad retry doesn't block the rest", async () => {
+      const service = getSessionService();
+      const errored: AgentSession = {
+        ...createMockSession({
+          taskId: "task-a",
+          taskRunId: "run-a",
+          status: "error",
+        }),
+        isCloud: true,
+      };
+
+      mockSessionStoreSetters.getSessions.mockReturnValue({ "run-a": errored });
+      mockSessionStoreSetters.getSessionByTaskId.mockReturnValue(errored);
+      mockTrpcCloudTask.retry.mutate.mockRejectedValueOnce(
+        new Error("network down"),
+      );
+
+      expect(() => service.retryUnhealthyCloudSessions()).not.toThrow();
+      await vi.waitFor(() => {
+        expect(mockTrpcCloudTask.retry.mutate).toHaveBeenCalled();
+      });
+    });
+  });
+
   describe("reset", () => {
     it("clears connecting tasks", () => {
       const service = getSessionService();

apps/code/src/renderer/features/sessions/service/service.ts

@@ -3166,6 +3166,30 @@ export class SessionService {
     }
   }
 
+  /**
+   * Retries every cloud session whose stream is in the `error` state, i.e. the
+   * main process exhausted its SSE reconnect budget and surfaced the manual
+   * Retry button. Invoked on window focus so users coming back to the app
+   * after a Django deploy, laptop sleep, or network blip don't have to click
+   * Retry themselves.
+   */
+  public retryUnhealthyCloudSessions(): void {
+    const sessions = sessionStoreSetters.getSessions();
+    for (const session of Object.values(sessions)) {
+      if (!session.isCloud) continue;
+      if (session.status !== "error") continue;
+      log.info("Auto-retrying errored cloud session on focus", {
+        taskId: session.taskId,
+      });
+      this.retryCloudTaskWatch(session.taskId).catch((error) => {
+        log.warn("Auto-retry of errored cloud session failed", {
+          taskId: session.taskId,
+          error,
+        });
+      });
+    }
+  }
+
   public updateSessionTaskTitle(taskId: string, taskTitle: string): void {
     const session = sessionStoreSetters.getSessionByTaskId(taskId);
     if (!session) return;