@devries-cameron20 / t3code-1 / commits / fb8fc1ffd3
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

refactor(web): disconnect and reconnect delays read a shared deadline instead of effect timers (#25363)

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

Julius Marminge committed Oct 26, 2026 at 01:15 UTC fb8fc1ffd3c038bf00050dc087e329b2f4add4eb
4 files changed +69 -55
apps/web/src/components/ChatView.logic.ts
+1 -13
@@ -111,7 +111,7 @@ type ThreadStructureRow = ThreadStructure["visibleTurnItems"][number];
111 export const LAST_INVOKED_SCRIPT_BY_PROJECT_KEY = "t3code:last-invoked-script-by-project";
112 export const MAX_HIDDEN_MOUNTED_TERMINAL_THREADS = 10;
113
114 -const ENVIRONMENT_RECONNECT_WARNING_GRACE_MS = 2_000;
114 +export const ENVIRONMENT_RECONNECT_WARNING_GRACE_MS = 2_000;
115
116 export function agentControlledBrowserCloseConfirmation(
117 surfaces: readonly RightPanelSurface[],
@@ -467,18 +467,6 @@ export function resolveDraftPromotionNavigationTarget(input: {
467 return runStarted || startupStopped || messagePersisted ? input.serverThreadRef : null;
468 }
469
470 -export function scheduleEnvironmentReconnectWarning(showWarning: () => void): () => void {
471 - const timeoutId = globalThis.setTimeout(showWarning, ENVIRONMENT_RECONNECT_WARNING_GRACE_MS);
472 - return () => globalThis.clearTimeout(timeoutId);
473 -}
474 -
475 -export function hasEnvironmentReconnectWarningGraceElapsed(
476 - activeEnvironmentId: EnvironmentId | null,
477 - elapsedEnvironmentId: EnvironmentId | null,
478 -): boolean {
479 - return activeEnvironmentId !== null && activeEnvironmentId === elapsedEnvironmentId;
480 -}
481 -
470 export function startNewThreadForProject(
471 projectRef: ScopedProjectRef | null,
472 handleNewThread: (projectRef: ScopedProjectRef) => Promise<unknown>,
apps/web/src/components/chat/useSystemComposerBanners.tsx
+8 -23
@@ -2,7 +2,7 @@ import { useStableCallback } from "../../hooks/useStableCallback";
2 import { type EnvironmentId } from "@t3tools/contracts";
3 import { type EnvironmentConnectionPresentation } from "@t3tools/client-runtime/connection";
4 import { useAtomValue } from "@effect/atom-react";
5 -import { useEffect, useState } from "react";
5 +import { useState } from "react";
6 import { useNavigate } from "@tanstack/react-router";
7 import {
8 isAtomCommandInterrupted,
@@ -13,14 +13,14 @@ import { stackedThreadToast, toastManager } from "../ui/toast";
13 import { environmentCatalog } from "../../connection/catalog";
14 import { ConnectionDiagnosisHeadline } from "../settings/ConnectionDiagnosisDetails";
15 import { isDesktopLocalConnectionTarget } from "../../connection/desktopLocal";
16 -import { useEnvironmentDisconnectDelay } from "../../hooks/useEnvironmentDisconnectDelay";
16 +import {
17 + useEnvironmentDisconnectDelay,
18 + useEnvironmentStateHeldFor,
19 +} from "../../hooks/useEnvironmentDisconnectDelay";
20 import { serverEnvironment } from "../../state/server";
21 import { type EnvironmentPresentation } from "../../state/environments";
22 import type { ComposerBannerStackItem } from "./ComposerBannerStack";
20 -import {
21 - hasEnvironmentReconnectWarningGraceElapsed,
22 - scheduleEnvironmentReconnectWarning,
23 -} from "../ChatView.logic";
23 +import { ENVIRONMENT_RECONNECT_WARNING_GRACE_MS } from "../ChatView.logic";
24 import { useAtomCommand } from "../../state/use-atom-command";
25 import { Button } from "../ui/button";
26 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
@@ -83,27 +83,12 @@ export function useSystemComposerBanners(input: SystemComposerBannersInput) {
83 activeEnvironmentConnectionPhase === "reconnecting"
84 ? (activeEnvironment?.environmentId ?? null)
85 : null;
86 - const [reconnectWarningGraceElapsedEnvironmentId, setReconnectWarningGraceElapsedEnvironmentId] =
87 - useState<EnvironmentId | null>(null);
86 // Each reconnect attempt gets its own grace period, including a later one to
87 // the same environment.
90 - const [graceReconnectingEnvironmentId, setGraceReconnectingEnvironmentId] = useState(
91 - activeReconnectingEnvironmentId,
92 - );
93 - if (graceReconnectingEnvironmentId !== activeReconnectingEnvironmentId) {
94 - setGraceReconnectingEnvironmentId(activeReconnectingEnvironmentId);
95 - setReconnectWarningGraceElapsedEnvironmentId(null);
96 - }
97 - const reconnectWarningGraceElapsed = hasEnvironmentReconnectWarningGraceElapsed(
88 + const reconnectWarningGraceElapsed = useEnvironmentStateHeldFor(
89 activeReconnectingEnvironmentId,
99 - reconnectWarningGraceElapsedEnvironmentId,
90 + ENVIRONMENT_RECONNECT_WARNING_GRACE_MS,
91 );
101 - useEffect(() => {
102 - if (activeReconnectingEnvironmentId === null) return;
103 - return scheduleEnvironmentReconnectWarning(() =>
104 - setReconnectWarningGraceElapsedEnvironmentId(activeReconnectingEnvironmentId),
105 - );
106 - }, [activeReconnectingEnvironmentId]);
92 const handleReconnectActiveEnvironment = async (environmentId: EnvironmentId) => {
93 const result = await retryEnvironment(environmentId);
94 if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
apps/web/src/hooks/useEnvironmentDisconnectDelay.browser.test.tsx new
+38
@@ -0,0 +1,38 @@
1 +import { EnvironmentId } from "@t3tools/contracts";
2 +import { describe, expect, it, vi } from "vite-plus/test";
3 +
4 +import { act, fakeTimers, render } from "../../test/render";
5 +import { useEnvironmentStateHeldFor } from "./useEnvironmentDisconnectDelay";
6 +
7 +const first = EnvironmentId.make("env-first");
8 +const second = EnvironmentId.make("env-second");
9 +
10 +function Probe(props: { environmentId: EnvironmentId | null }) {
11 + const held = useEnvironmentStateHeldFor(props.environmentId, 1_000);
12 + return <output>{held ? "held" : "waiting"}</output>;
13 +}
14 +
15 +describe("useEnvironmentStateHeldFor", () => {
16 + it("restarts the delay whenever the environment changes", async () => {
17 + await using screen = await render(<Probe environmentId={first} />, {
18 + // A bare hook probe; nothing here navigates.
19 + router: false,
20 + });
21 + using _timers = fakeTimers();
22 + await screen.rerender(<Probe environmentId={second} />);
23 + await expect.element(screen.getByText("waiting")).toBeInTheDocument();
24 +
25 + await act(() => vi.advanceTimersByTime(999));
26 + await expect.element(screen.getByText("waiting")).toBeInTheDocument();
27 +
28 + await act(() => vi.advanceTimersByTime(1));
29 + await expect.element(screen.getByText("held")).toBeInTheDocument();
30 +
31 + await screen.rerender(<Probe environmentId={null} />);
32 + await expect.element(screen.getByText("waiting")).toBeInTheDocument();
33 + await screen.rerender(<Probe environmentId={second} />);
34 + await expect.element(screen.getByText("waiting")).toBeInTheDocument();
35 + await act(() => vi.advanceTimersByTime(1_000));
36 + await expect.element(screen.getByText("held")).toBeInTheDocument();
37 + });
38 +});
apps/web/src/hooks/useEnvironmentDisconnectDelay.ts
+22 -19
@@ -1,24 +1,27 @@
1 +import { deadlineAfter } from "@t3tools/client-runtime/clock";
2 import type { EnvironmentId } from "@t3tools/contracts";
2 -import { useEffect, useState } from "react";
3 +import { useState } from "react";
4
4 -export function useEnvironmentDisconnectDelay(unavailableEnvironmentId: EnvironmentId | null) {
5 - const [delay, setDelay] = useState({ environmentId: unavailableEnvironmentId, elapsed: false });
6 - if (delay.environmentId !== unavailableEnvironmentId) {
7 - setDelay({ environmentId: unavailableEnvironmentId, elapsed: false });
8 - }
5 +import { useDeadlinePassed } from "./useDeadline";
6 +
7 +const DISCONNECT_DELAY_MS = 20_000;
8
10 - useEffect(() => {
11 - if (unavailableEnvironmentId === null) return;
12 - const timeout = setTimeout(
13 - () => setDelay({ environmentId: unavailableEnvironmentId, elapsed: true }),
14 - 20_000,
15 - );
16 - return () => clearTimeout(timeout);
17 - }, [unavailableEnvironmentId]);
9 +export function useEnvironmentDisconnectDelay(unavailableEnvironmentId: EnvironmentId | null) {
10 + return useEnvironmentStateHeldFor(unavailableEnvironmentId, DISCONNECT_DELAY_MS);
11 +}
12
19 - return (
20 - unavailableEnvironmentId !== null &&
21 - delay.environmentId === unavailableEnvironmentId &&
22 - delay.elapsed
23 - );
13 +/**
14 + * Whether `environmentId` has stayed the same non-null value for `delayMs`. Every change starts a
15 + * new delay, so leaving and returning to an id restarts it.
16 + */
17 +export function useEnvironmentStateHeldFor(environmentId: EnvironmentId | null, delayMs: number) {
18 + const [held, setHeld] = useState(() => ({
19 + environmentId,
20 + deadline: deadlineAfter(delayMs),
21 + }));
22 + if (held.environmentId !== environmentId) {
23 + setHeld({ environmentId, deadline: deadlineAfter(delayMs) });
24 + }
25 + const elapsed = useDeadlinePassed(held.environmentId === null ? null : held.deadline);
26 + return environmentId !== null && held.environmentId === environmentId && elapsed;
27 }