The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 22, 20:45 UTC
refactor(web): ChatView's machine and server-update banners live in useSystemComposerBanners (#22710)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 21, 2026 at 01:36 UTC
030be16739858801ba4ebd125a1da63aababcca7
2 files changed
+338
-277
apps/web/src/components/ChatView.tsx
+15
-277
@@ -75,7 +75,6 @@ import {
75
resolveProjectProviderInstanceEnabled,
76
RuntimeMode,
77
} from "@t3tools/contracts";
78
-import { type EnvironmentConnectionPresentation } from "@t3tools/client-runtime/connection";
78
import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
79
import { wasBootstrapThreadDeleted } from "@t3tools/client-runtime/errors";
80
import { readPastedComposerContext } from "./composerInlineTokenPaste";
@@ -242,7 +241,6 @@ import {
241
GitBranchIcon,
242
ShieldQuestionIcon,
243
TargetIcon,
245
- WifiOffIcon,
244
} from "lucide-react";
245
import { cn } from "~/lib/utils";
246
import { COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS } from "~/workspaceTitlebar";
@@ -318,10 +316,6 @@ import {
316
terminalContextReference,
317
} from "../lib/composerContextRecords";
318
import { type ReviewCommentContext } from "../reviewCommentContext";
321
-import { environmentCatalog } from "../connection/catalog";
322
-import { ConnectionDiagnosisHeadline } from "./settings/ConnectionDiagnosisDetails";
323
-import { isDesktopLocalConnectionTarget } from "../connection/desktopLocal";
324
-import { useEnvironmentDisconnectDelay } from "../hooks/useEnvironmentDisconnectDelay";
319
import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
320
import { useKnownTerminalSessions, useThreadRunningTerminalIds } from "../state/terminalSessions";
321
import { useEnvironmentQuery } from "../state/query";
@@ -447,8 +441,6 @@ import {
441
deriveCommittedServerUserMessageIds,
442
deriveComposerSendState,
443
dismissBranchMismatchForSession,
450
- hasEnvironmentReconnectWarningGraceElapsed,
451
- scheduleEnvironmentReconnectWarning,
444
isBranchMismatchDismissedForSession,
445
shouldShowBranchMismatchBanner,
446
shouldShowPlanFollowUpPrompt,
@@ -493,21 +485,6 @@ import { useOrchestrationCommand } from "../state/use-orchestration-command";
485
import { useAtomQueryRunner } from "../state/use-atom-query-runner";
486
import { Button, InlineButton } from "./ui/button";
487
import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
496
-import { ServerUpdateAction, serverUpdateStageLabel } from "./ServerUpdateAction";
497
-import { useAutoBalanceUpdateBanner } from "./chat/useAutoBalanceUpdateBanner";
498
-import { ComposerServerUpdateIcon } from "./chat/ComposerServerUpdateStatus";
499
-import {
500
- buildVersionMismatchDismissalKey,
501
- dismissServerUpdateFailure,
502
- dismissVersionMismatch,
503
- isServerUpdateFailureDismissed,
504
- isVersionMismatchDismissed,
505
- resolveServerConfigVersionMismatch,
506
- resolveServerSelfUpdateCapability,
507
- serverUpdateGuidance,
508
- supportsDesktopAppUpdate,
509
- supportsServerUpdateThreadContinuation,
510
-} from "../versionSkew";
488
import { useAssetUrls } from "../assets/assetUrls";
489
import {
490
ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
@@ -518,6 +495,10 @@ import { ThreadVisitWatermark } from "./chat/ThreadVisitWatermark";
495
import { ChatTerminalDrawers } from "./chat/ChatTerminalDrawers";
496
import { ChatRightPanel } from "./chat/ChatRightPanel";
497
import { useTimelineFollow } from "./chat/useTimelineFollow";
498
+import {
499
+ type EnvironmentUnavailableState,
500
+ useSystemComposerBanners,
501
+} from "./chat/useSystemComposerBanners";
502
import { useDraftHeroLayoutTransition } from "./chat/useDraftHeroLayoutTransition";
503
import { useLocalDispatchState } from "./chat/useLocalDispatchState";
504
import {
@@ -546,11 +527,6 @@ const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];
527
const EMPTY_AUTO_UPDATE_ENVIRONMENTS: ReadonlyArray<EnvironmentPresentation> = [];
528
529
const EMPTY_PENDING_FILE_SURFACE_IDS: ReadonlySet<string> = new Set();
549
-type EnvironmentUnavailableState = {
550
- readonly environmentId: EnvironmentId;
551
- readonly label: string;
552
- readonly connection: EnvironmentConnectionPresentation;
553
-};
530
531
const SCRIPT_TERMINAL_COLS = 120;
532
const SCRIPT_TERMINAL_ROWS = 30;
@@ -656,10 +632,6 @@ export default function ChatView(props: ChatViewProps) {
632
const { environments } = useEnvironments();
633
const providersByEnvironment = useEnvironmentProviders();
634
const primaryEnvironment = usePrimaryEnvironment();
659
- const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, { reportFailure: false });
660
- const setEnvironmentEnabled = useAtomCommand(environmentCatalog.setEnabled, {
661
- reportFailure: false,
662
- });
635
const environmentById = new Map(
636
environments.map((environment) => [environment.environmentId, environment]),
637
);
@@ -1517,35 +1489,8 @@ export default function ChatView(props: ChatViewProps) {
1489
}, [activeProjectRef, activeThreadRef]);
1490
const activeEnvironment =
1491
activeThread == null ? null : (environmentById.get(activeThread.environmentId) ?? null);
1520
- const activeEnvironmentConnectionPhase = activeEnvironment?.connection.phase ?? "available";
1492
const activeEnvironmentUnavailable =
1522
- activeEnvironment !== null && activeEnvironmentConnectionPhase !== "connected";
1523
- const activeReconnectingEnvironmentId =
1524
- activeEnvironmentConnectionPhase === "connecting" ||
1525
- activeEnvironmentConnectionPhase === "reconnecting"
1526
- ? (activeEnvironment?.environmentId ?? null)
1527
- : null;
1528
- const [reconnectWarningGraceElapsedEnvironmentId, setReconnectWarningGraceElapsedEnvironmentId] =
1529
- useState<EnvironmentId | null>(null);
1530
- // Each reconnect attempt gets its own grace period, including a later one to
1531
- // the same environment.
1532
- const [graceReconnectingEnvironmentId, setGraceReconnectingEnvironmentId] = useState(
1533
- activeReconnectingEnvironmentId,
1534
- );
1535
- if (graceReconnectingEnvironmentId !== activeReconnectingEnvironmentId) {
1536
- setGraceReconnectingEnvironmentId(activeReconnectingEnvironmentId);
1537
- setReconnectWarningGraceElapsedEnvironmentId(null);
1538
- }
1539
- const reconnectWarningGraceElapsed = hasEnvironmentReconnectWarningGraceElapsed(
1540
- activeReconnectingEnvironmentId,
1541
- reconnectWarningGraceElapsedEnvironmentId,
1542
- );
1543
- useEffect(() => {
1544
- if (activeReconnectingEnvironmentId === null) return;
1545
- return scheduleEnvironmentReconnectWarning(() =>
1546
- setReconnectWarningGraceElapsedEnvironmentId(activeReconnectingEnvironmentId),
1547
- );
1548
- }, [activeReconnectingEnvironmentId]);
1493
+ activeEnvironment !== null && activeEnvironment.connection.phase !== "connected";
1494
const activeEnvironmentUnavailableLabel = activeEnvironment?.label ?? null;
1495
const activeEnvironmentUnavailableState = (() => {
1496
if (!activeEnvironmentUnavailable || !activeEnvironmentUnavailableLabel || !activeEnvironment) {
@@ -1558,53 +1503,6 @@ export default function ChatView(props: ChatViewProps) {
1503
connection: activeEnvironment.connection,
1504
};
1505
})() as EnvironmentUnavailableState | null;
1561
- const handleReconnectActiveEnvironment = async (environmentId: EnvironmentId) => {
1562
- const result = await retryEnvironment(environmentId);
1563
- if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
1564
- const error = squashAtomCommandFailure(result);
1565
- toastManager.add(
1566
- stackedThreadToast({
1567
- type: "error",
1568
- title: "Could not reconnect environment",
1569
- description: error instanceof Error ? error.message : "Failed to reconnect.",
1570
- }),
1571
- );
1572
- }
1573
- };
1574
- const handleReconnectActiveEnvironmentStable = useStableCallback(
1575
- handleReconnectActiveEnvironment,
1576
- );
1577
- const disconnectDelayElapsed = useEnvironmentDisconnectDelay(
1578
- activeEnvironmentUnavailable ? activeEnvironment.environmentId : null,
1579
- );
1580
- const canDisconnectActiveEnvironment =
1581
- disconnectDelayElapsed &&
1582
- activeEnvironment !== null &&
1583
- activeEnvironment.entry.target._tag !== "PrimaryConnectionTarget" &&
1584
- !isDesktopLocalConnectionTarget(activeEnvironment.entry.target);
1585
- const [disconnectingEnvironment, setDisconnectingEnvironment] = useState(false);
1586
- const handleDisconnectActiveEnvironment = async (environmentId: EnvironmentId) => {
1587
- setDisconnectingEnvironment(true);
1588
- const result = await setEnvironmentEnabled({ environmentId, enabled: false });
1589
- setDisconnectingEnvironment(false);
1590
- if (result._tag === "Failure") {
1591
- if (!isAtomCommandInterrupted(result)) {
1592
- const error = squashAtomCommandFailure(result);
1593
- toastManager.add(
1594
- stackedThreadToast({
1595
- type: "error",
1596
- title: "Could not disconnect server",
1597
- description: error instanceof Error ? error.message : "Failed to disconnect.",
1598
- }),
1599
- );
1600
- }
1601
- return;
1602
- }
1603
- void navigate({ to: "/", replace: true });
1604
- };
1605
- const handleDisconnectActiveEnvironmentStable = useStableCallback(
1606
- handleDisconnectActiveEnvironment,
1607
- );
1506
const { openScratchProject } = useScratchProject();
1507
const activeProjectIsScratch =
1508
activeProject !== null &&
@@ -1774,176 +1672,16 @@ export default function ChatView(props: ChatViewProps) {
1672
return environment ? [environment] : [];
1673
})
1674
: EMPTY_AUTO_UPDATE_ENVIRONMENTS;
1777
- const autoBalanceUpdateBanner = useAutoBalanceUpdateBanner(autoUpdateEnvironments);
1778
- const versionMismatch = resolveServerConfigVersionMismatch(serverConfig);
1779
- const versionMismatchDismissKey =
1780
- versionMismatch && activeThread
1781
- ? buildVersionMismatchDismissalKey(activeThread.environmentId, versionMismatch)
1782
- : null;
1783
- const [dismissedVersionMismatchKey, setDismissedVersionMismatchKey] = useState<string | null>(
1784
- null,
1785
- );
1786
- const versionMismatchDismissed =
1787
- versionMismatchDismissKey === dismissedVersionMismatchKey ||
1788
- isVersionMismatchDismissed(versionMismatchDismissKey);
1789
- const showVersionMismatchBanner =
1790
- versionMismatch !== null && versionMismatchDismissKey !== null && !versionMismatchDismissed;
1791
- const hasMultipleRegisteredEnvironments = environments.length > 1;
1792
- const versionMismatchServerLabel =
1793
- hasMultipleRegisteredEnvironments && activeThread
1794
- ? `${environmentById.get(activeThread.environmentId)?.label ?? serverConfig?.environment.label ?? activeThread.environmentId} server`
1795
- : "server";
1796
- const serverUpdateEnvironmentId = activeThread?.environmentId ?? null;
1797
- const versionMismatchSelfUpdate = resolveServerSelfUpdateCapability(serverConfig);
1798
- const versionMismatchInstallation = serverConfig?.environment.capabilities.serverInstallation;
1799
- const versionMismatchDesktopAppUpdate = supportsDesktopAppUpdate(serverConfig);
1800
- const versionMismatchThreadContinuation = supportsServerUpdateThreadContinuation(serverConfig);
1801
- const serverUpdateState = useAtomValue(
1802
- serverEnvironment.updateStateAtom(serverUpdateEnvironmentId),
1803
- );
1804
- const [dismissedServerUpdateState, setDismissedServerUpdateState] = useState<
1805
- typeof serverUpdateState | null
1806
- >(null);
1807
- const serverUpdateFailureDismissed =
1808
- serverUpdateState === dismissedServerUpdateState ||
1809
- isServerUpdateFailureDismissed(serverUpdateState);
1810
- const systemComposerBannerItems = (() => {
1811
- const items: ComposerBannerStackItem[] = [];
1812
- const updateRunning = serverUpdateState.status === "running";
1813
- const unavailableConnection = activeEnvironmentUnavailableState?.connection ?? null;
1814
- const disconnectAction =
1815
- canDisconnectActiveEnvironment && activeEnvironmentUnavailableState ? (
1816
- <Button
1817
- size="xs"
1818
- variant="ghost"
1819
- disabled={disconnectingEnvironment}
1820
- title="Hide this server's threads. Switch it on again in Connections."
1821
- onClick={() =>
1822
- void handleDisconnectActiveEnvironmentStable(
1823
- activeEnvironmentUnavailableState.environmentId,
1824
- )
1825
- }
1826
- >
1827
- Disconnect server
1828
- </Button>
1829
- ) : undefined;
1830
- const environmentReconnecting =
1831
- unavailableConnection !== null &&
1832
- (unavailableConnection.phase === "connecting" ||
1833
- unavailableConnection.phase === "reconnecting");
1834
- const suppressUnavailableBanner =
1835
- environmentReconnecting && (updateRunning || !reconnectWarningGraceElapsed);
1836
- if (activeEnvironmentUnavailableState && unavailableConnection && !suppressUnavailableBanner) {
1837
- items.push({
1838
- id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`,
1839
- variant: unavailableConnection.phase === "error" ? "error" : "warning",
1840
- icon: <WifiOffIcon />,
1841
- title: `${activeEnvironmentUnavailableState.label} is ${environmentReconnecting ? "reconnecting" : "offline"}`,
1842
- description: activeEnvironment ? (
1843
- <ConnectionDiagnosisHeadline environment={activeEnvironment} />
1844
- ) : undefined,
1845
- actions: (
1846
- <>
1847
- {!environmentReconnecting ? (
1848
- <Button
1849
- size="xs"
1850
- variant="ghost"
1851
- onClick={() =>
1852
- void handleReconnectActiveEnvironmentStable(
1853
- activeEnvironmentUnavailableState.environmentId,
1854
- )
1855
- }
1856
- >
1857
- Reconnect
1858
- </Button>
1859
- ) : null}
1860
- {disconnectAction}
1861
- </>
1862
- ),
1863
- });
1864
- }
1865
- if (
1866
- !automaticEnvironment &&
1867
- serverUpdateEnvironmentId &&
1868
- (serverUpdateState.status === "idle"
1869
- ? showVersionMismatchBanner
1870
- : !serverUpdateFailureDismissed)
1871
- ) {
1872
- const updateInProgress = serverUpdateState.status === "running";
1873
- const updateFailed = serverUpdateState.status === "failed";
1874
- items.push({
1875
- id: `server-version:${serverUpdateEnvironmentId}`,
1876
- variant: updateFailed ? "error" : "default",
1877
- priority: updateInProgress ? "urgent" : "notice",
1878
- icon: <ComposerServerUpdateIcon status={serverUpdateState.status} />,
1879
- title:
1880
- updateInProgress || updateFailed ? (
1881
- `${updateFailed ? "Could not update" : "Updating"} ${versionMismatchServerLabel}`
1882
- ) : versionMismatch ? (
1883
- <Tooltip>
1884
- <TooltipTrigger
1885
- render={
1886
- <button
1887
- type="button"
1888
- className="block max-w-full cursor-help truncate rounded-sm text-left"
1889
- >
1890
- Server update available
1891
- </button>
1892
- }
1893
- />
1894
- <TooltipPopup side="top">
1895
- {versionMismatchServerLabel} {versionMismatch.serverVersion}{" "}
1896
- <span aria-hidden="true">→</span> {versionMismatch.clientVersion}
1897
- </TooltipPopup>
1898
- </Tooltip>
1899
- ) : (
1900
- "Server update available"
1901
- ),
1902
- description:
1903
- serverUpdateState.status === "failed"
1904
- ? serverUpdateState.message
1905
- : serverUpdateState.status === "running"
1906
- ? serverUpdateStageLabel(serverUpdateState.stage)
1907
- : versionMismatchSelfUpdate !== null &&
1908
- (versionMismatchSelfUpdate !== "desktop-managed" ||
1909
- !versionMismatchDesktopAppUpdate)
1910
- ? serverUpdateGuidance(versionMismatchSelfUpdate)
1911
- : undefined,
1912
- actions: updateInProgress ? (
1913
- disconnectAction
1914
- ) : !versionMismatch ||
1915
- (versionMismatchSelfUpdate === "desktop-managed" &&
1916
- !versionMismatchDesktopAppUpdate) ? undefined : (
1917
- <ServerUpdateAction
1918
- environmentId={serverUpdateEnvironmentId}
1919
- serverLabel={versionMismatchServerLabel}
1920
- selfUpdate={versionMismatchSelfUpdate}
1921
- installation={versionMismatchInstallation}
1922
- desktopAppUpdate={versionMismatchDesktopAppUpdate}
1923
- threadContinuation={versionMismatchThreadContinuation}
1924
- targetVersion={versionMismatch.clientVersion}
1925
- label={updateFailed ? "Retry" : "Update"}
1926
- variant="ghost"
1927
- />
1928
- ),
1929
- ...(updateInProgress || (!updateFailed && !versionMismatchDismissKey)
1930
- ? {}
1931
- : {
1932
- dismissLabel: "Dismiss update notice",
1933
- onDismiss: () => {
1934
- if (updateFailed) {
1935
- dismissServerUpdateFailure(serverUpdateState);
1936
- setDismissedServerUpdateState(serverUpdateState);
1937
- }
1938
- dismissVersionMismatch(versionMismatchDismissKey);
1939
- setDismissedVersionMismatchKey(versionMismatchDismissKey);
1940
- },
1941
- }),
1942
- });
1943
- }
1944
- if (autoBalanceUpdateBanner) items.push(autoBalanceUpdateBanner);
1945
- return items;
1946
- })() as ComposerBannerStackItem[];
1675
+ const systemComposerBannerItems = useSystemComposerBanners({
1676
+ activeEnvironment,
1677
+ activeEnvironmentUnavailable,
1678
+ activeEnvironmentUnavailableState,
1679
+ activeThreadEnvironmentId: activeThread?.environmentId ?? null,
1680
+ serverConfig,
1681
+ hasMultipleRegisteredEnvironments: environments.length > 1,
1682
+ automaticEnvironment,
1683
+ autoUpdateEnvironments,
1684
+ });
1685
const providerInstanceEntries = sortProviderInstanceEntries(
1686
applyProviderInstanceSettings(
1687
deriveProviderInstanceEntries(providerStatuses),
apps/web/src/components/chat/useSystemComposerBanners.tsx
new
+323
@@ -0,0 +1,323 @@
1
+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";
6
+import { useNavigate } from "@tanstack/react-router";
7
+import {
8
+ isAtomCommandInterrupted,
9
+ squashAtomCommandFailure,
10
+} from "@t3tools/client-runtime/state/runtime";
11
+import { WifiOffIcon } from "lucide-react";
12
+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";
17
+import { serverEnvironment } from "../../state/server";
18
+import { type EnvironmentPresentation } from "../../state/environments";
19
+import type { ComposerBannerStackItem } from "./ComposerBannerStack";
20
+import {
21
+ hasEnvironmentReconnectWarningGraceElapsed,
22
+ scheduleEnvironmentReconnectWarning,
23
+} 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";
27
+import { ServerUpdateAction, serverUpdateStageLabel } from "../ServerUpdateAction";
28
+import { useAutoBalanceUpdateBanner } from "./useAutoBalanceUpdateBanner";
29
+import { ComposerServerUpdateIcon } from "./ComposerServerUpdateStatus";
30
+import {
31
+ buildVersionMismatchDismissalKey,
32
+ dismissServerUpdateFailure,
33
+ dismissVersionMismatch,
34
+ isServerUpdateFailureDismissed,
35
+ isVersionMismatchDismissed,
36
+ resolveServerConfigVersionMismatch,
37
+ resolveServerSelfUpdateCapability,
38
+ serverUpdateGuidance,
39
+ supportsDesktopAppUpdate,
40
+ supportsServerUpdateThreadContinuation,
41
+} from "../../versionSkew";
42
+
43
+export type EnvironmentUnavailableState = {
44
+ readonly environmentId: EnvironmentId;
45
+ readonly label: string;
46
+ readonly connection: EnvironmentConnectionPresentation;
47
+};
48
+
49
+interface SystemComposerBannersInput {
50
+ readonly activeEnvironment: EnvironmentPresentation | null;
51
+ readonly activeEnvironmentUnavailable: boolean;
52
+ readonly activeEnvironmentUnavailableState: EnvironmentUnavailableState | null;
53
+ readonly activeThreadEnvironmentId: EnvironmentId | null;
54
+ readonly serverConfig: EnvironmentPresentation["serverConfig"] | null;
55
+ readonly hasMultipleRegisteredEnvironments: boolean;
56
+ readonly automaticEnvironment: boolean;
57
+ readonly autoUpdateEnvironments: ReadonlyArray<EnvironmentPresentation>;
58
+}
59
+
60
+/**
61
+ * The composer banners about the machine itself: offline or reconnecting,
62
+ * a server update, and auto-balanced machines that need one.
63
+ */
64
+export function useSystemComposerBanners(input: SystemComposerBannersInput) {
65
+ const {
66
+ activeEnvironment,
67
+ activeEnvironmentUnavailable,
68
+ activeEnvironmentUnavailableState,
69
+ activeThreadEnvironmentId,
70
+ serverConfig,
71
+ hasMultipleRegisteredEnvironments,
72
+ automaticEnvironment,
73
+ autoUpdateEnvironments,
74
+ } = input;
75
+ const navigate = useNavigate();
76
+ const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, { reportFailure: false });
77
+ const setEnvironmentEnabled = useAtomCommand(environmentCatalog.setEnabled, {
78
+ reportFailure: false,
79
+ });
80
+ const activeEnvironmentConnectionPhase = activeEnvironment?.connection.phase ?? "available";
81
+ const activeReconnectingEnvironmentId =
82
+ activeEnvironmentConnectionPhase === "connecting" ||
83
+ activeEnvironmentConnectionPhase === "reconnecting"
84
+ ? (activeEnvironment?.environmentId ?? null)
85
+ : null;
86
+ const [reconnectWarningGraceElapsedEnvironmentId, setReconnectWarningGraceElapsedEnvironmentId] =
87
+ useState<EnvironmentId | null>(null);
88
+ // Each reconnect attempt gets its own grace period, including a later one to
89
+ // 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(
98
+ activeReconnectingEnvironmentId,
99
+ reconnectWarningGraceElapsedEnvironmentId,
100
+ );
101
+ useEffect(() => {
102
+ if (activeReconnectingEnvironmentId === null) return;
103
+ return scheduleEnvironmentReconnectWarning(() =>
104
+ setReconnectWarningGraceElapsedEnvironmentId(activeReconnectingEnvironmentId),
105
+ );
106
+ }, [activeReconnectingEnvironmentId]);
107
+ const handleReconnectActiveEnvironment = async (environmentId: EnvironmentId) => {
108
+ const result = await retryEnvironment(environmentId);
109
+ if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
110
+ const error = squashAtomCommandFailure(result);
111
+ toastManager.add(
112
+ stackedThreadToast({
113
+ type: "error",
114
+ title: "Could not reconnect environment",
115
+ description: error instanceof Error ? error.message : "Failed to reconnect.",
116
+ }),
117
+ );
118
+ }
119
+ };
120
+ const handleReconnectActiveEnvironmentStable = useStableCallback(
121
+ handleReconnectActiveEnvironment,
122
+ );
123
+ const disconnectDelayElapsed = useEnvironmentDisconnectDelay(
124
+ activeEnvironmentUnavailable && activeEnvironment ? activeEnvironment.environmentId : null,
125
+ );
126
+ const canDisconnectActiveEnvironment =
127
+ disconnectDelayElapsed &&
128
+ activeEnvironment !== null &&
129
+ activeEnvironment.entry.target._tag !== "PrimaryConnectionTarget" &&
130
+ !isDesktopLocalConnectionTarget(activeEnvironment.entry.target);
131
+ const [disconnectingEnvironment, setDisconnectingEnvironment] = useState(false);
132
+ const handleDisconnectActiveEnvironment = async (environmentId: EnvironmentId) => {
133
+ setDisconnectingEnvironment(true);
134
+ const result = await setEnvironmentEnabled({ environmentId, enabled: false });
135
+ setDisconnectingEnvironment(false);
136
+ if (result._tag === "Failure") {
137
+ if (!isAtomCommandInterrupted(result)) {
138
+ const error = squashAtomCommandFailure(result);
139
+ toastManager.add(
140
+ stackedThreadToast({
141
+ type: "error",
142
+ title: "Could not disconnect server",
143
+ description: error instanceof Error ? error.message : "Failed to disconnect.",
144
+ }),
145
+ );
146
+ }
147
+ return;
148
+ }
149
+ void navigate({ to: "/", replace: true });
150
+ };
151
+ const handleDisconnectActiveEnvironmentStable = useStableCallback(
152
+ handleDisconnectActiveEnvironment,
153
+ );
154
+ const autoBalanceUpdateBanner = useAutoBalanceUpdateBanner(autoUpdateEnvironments);
155
+ const versionMismatch = resolveServerConfigVersionMismatch(serverConfig);
156
+ const versionMismatchDismissKey =
157
+ versionMismatch && activeThreadEnvironmentId !== null
158
+ ? buildVersionMismatchDismissalKey(activeThreadEnvironmentId, versionMismatch)
159
+ : null;
160
+ const [dismissedVersionMismatchKey, setDismissedVersionMismatchKey] = useState<string | null>(
161
+ null,
162
+ );
163
+ const versionMismatchDismissed =
164
+ versionMismatchDismissKey === dismissedVersionMismatchKey ||
165
+ isVersionMismatchDismissed(versionMismatchDismissKey);
166
+ const showVersionMismatchBanner =
167
+ versionMismatch !== null && versionMismatchDismissKey !== null && !versionMismatchDismissed;
168
+ const versionMismatchServerLabel =
169
+ hasMultipleRegisteredEnvironments && activeThreadEnvironmentId !== null
170
+ ? `${activeEnvironment?.label ?? serverConfig?.environment.label ?? activeThreadEnvironmentId} server`
171
+ : "server";
172
+ const serverUpdateEnvironmentId = activeThreadEnvironmentId;
173
+ const versionMismatchSelfUpdate = resolveServerSelfUpdateCapability(serverConfig);
174
+ const versionMismatchInstallation = serverConfig?.environment.capabilities.serverInstallation;
175
+ const versionMismatchDesktopAppUpdate = supportsDesktopAppUpdate(serverConfig);
176
+ const versionMismatchThreadContinuation = supportsServerUpdateThreadContinuation(serverConfig);
177
+ const serverUpdateState = useAtomValue(
178
+ serverEnvironment.updateStateAtom(serverUpdateEnvironmentId),
179
+ );
180
+ const [dismissedServerUpdateState, setDismissedServerUpdateState] = useState<
181
+ typeof serverUpdateState | null
182
+ >(null);
183
+ const serverUpdateFailureDismissed =
184
+ serverUpdateState === dismissedServerUpdateState ||
185
+ isServerUpdateFailureDismissed(serverUpdateState);
186
+ return (() => {
187
+ const items: ComposerBannerStackItem[] = [];
188
+ const updateRunning = serverUpdateState.status === "running";
189
+ const unavailableConnection = activeEnvironmentUnavailableState?.connection ?? null;
190
+ const disconnectAction =
191
+ canDisconnectActiveEnvironment && activeEnvironmentUnavailableState ? (
192
+ <Button
193
+ size="xs"
194
+ variant="ghost"
195
+ disabled={disconnectingEnvironment}
196
+ title="Hide this server's threads. Switch it on again in Connections."
197
+ onClick={() =>
198
+ void handleDisconnectActiveEnvironmentStable(
199
+ activeEnvironmentUnavailableState.environmentId,
200
+ )
201
+ }
202
+ >
203
+ Disconnect server
204
+ </Button>
205
+ ) : undefined;
206
+ const environmentReconnecting =
207
+ unavailableConnection !== null &&
208
+ (unavailableConnection.phase === "connecting" ||
209
+ unavailableConnection.phase === "reconnecting");
210
+ const suppressUnavailableBanner =
211
+ environmentReconnecting && (updateRunning || !reconnectWarningGraceElapsed);
212
+ if (activeEnvironmentUnavailableState && unavailableConnection && !suppressUnavailableBanner) {
213
+ items.push({
214
+ id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`,
215
+ variant: unavailableConnection.phase === "error" ? "error" : "warning",
216
+ icon: <WifiOffIcon />,
217
+ title: `${activeEnvironmentUnavailableState.label} is ${environmentReconnecting ? "reconnecting" : "offline"}`,
218
+ description: activeEnvironment ? (
219
+ <ConnectionDiagnosisHeadline environment={activeEnvironment} />
220
+ ) : undefined,
221
+ actions: (
222
+ <>
223
+ {!environmentReconnecting ? (
224
+ <Button
225
+ size="xs"
226
+ variant="ghost"
227
+ onClick={() =>
228
+ void handleReconnectActiveEnvironmentStable(
229
+ activeEnvironmentUnavailableState.environmentId,
230
+ )
231
+ }
232
+ >
233
+ Reconnect
234
+ </Button>
235
+ ) : null}
236
+ {disconnectAction}
237
+ </>
238
+ ),
239
+ });
240
+ }
241
+ if (
242
+ !automaticEnvironment &&
243
+ serverUpdateEnvironmentId &&
244
+ (serverUpdateState.status === "idle"
245
+ ? showVersionMismatchBanner
246
+ : !serverUpdateFailureDismissed)
247
+ ) {
248
+ const updateInProgress = serverUpdateState.status === "running";
249
+ const updateFailed = serverUpdateState.status === "failed";
250
+ items.push({
251
+ id: `server-version:${serverUpdateEnvironmentId}`,
252
+ variant: updateFailed ? "error" : "default",
253
+ priority: updateInProgress ? "urgent" : "notice",
254
+ icon: <ComposerServerUpdateIcon status={serverUpdateState.status} />,
255
+ title:
256
+ updateInProgress || updateFailed ? (
257
+ `${updateFailed ? "Could not update" : "Updating"} ${versionMismatchServerLabel}`
258
+ ) : versionMismatch ? (
259
+ <Tooltip>
260
+ <TooltipTrigger
261
+ render={
262
+ <button
263
+ type="button"
264
+ className="block max-w-full cursor-help truncate rounded-sm text-left"
265
+ >
266
+ Server update available
267
+ </button>
268
+ }
269
+ />
270
+ <TooltipPopup side="top">
271
+ {versionMismatchServerLabel} {versionMismatch.serverVersion}{" "}
272
+ <span aria-hidden="true">→</span> {versionMismatch.clientVersion}
273
+ </TooltipPopup>
274
+ </Tooltip>
275
+ ) : (
276
+ "Server update available"
277
+ ),
278
+ description:
279
+ serverUpdateState.status === "failed"
280
+ ? serverUpdateState.message
281
+ : serverUpdateState.status === "running"
282
+ ? serverUpdateStageLabel(serverUpdateState.stage)
283
+ : versionMismatchSelfUpdate !== null &&
284
+ (versionMismatchSelfUpdate !== "desktop-managed" ||
285
+ !versionMismatchDesktopAppUpdate)
286
+ ? serverUpdateGuidance(versionMismatchSelfUpdate)
287
+ : undefined,
288
+ actions: updateInProgress ? (
289
+ disconnectAction
290
+ ) : !versionMismatch ||
291
+ (versionMismatchSelfUpdate === "desktop-managed" &&
292
+ !versionMismatchDesktopAppUpdate) ? undefined : (
293
+ <ServerUpdateAction
294
+ environmentId={serverUpdateEnvironmentId}
295
+ serverLabel={versionMismatchServerLabel}
296
+ selfUpdate={versionMismatchSelfUpdate}
297
+ installation={versionMismatchInstallation}
298
+ desktopAppUpdate={versionMismatchDesktopAppUpdate}
299
+ threadContinuation={versionMismatchThreadContinuation}
300
+ targetVersion={versionMismatch.clientVersion}
301
+ label={updateFailed ? "Retry" : "Update"}
302
+ variant="ghost"
303
+ />
304
+ ),
305
+ ...(updateInProgress || (!updateFailed && !versionMismatchDismissKey)
306
+ ? {}
307
+ : {
308
+ dismissLabel: "Dismiss update notice",
309
+ onDismiss: () => {
310
+ if (updateFailed) {
311
+ dismissServerUpdateFailure(serverUpdateState);
312
+ setDismissedServerUpdateState(serverUpdateState);
313
+ }
314
+ dismissVersionMismatch(versionMismatchDismissKey);
315
+ setDismissedVersionMismatchKey(versionMismatchDismissKey);
316
+ },
317
+ }),
318
+ });
319
+ }
320
+ if (autoBalanceUpdateBanner) items.push(autoBalanceUpdateBanner);
321
+ return items;
322
+ })() as ComposerBannerStackItem[];
323
+}