@devries-cameron20 / t3code-1 / commits / 030be16739
Fork 0

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

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 +}