@devries-cameron20 / t3code-1 / commits / 9a391eb3f5
Fork 0

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

fix(web): clear stale resource monitor errors after retry (#24229)

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com> Co-authored-by: Yordis Prieto <yordis.prieto@gmail.com>

Julius Marminge committed Oct 23, 2026 at 13:47 UTC 9a391eb3f55b738113b61768cf2d8263b4f3ac2e
3 files changed +283
apps/web/src/components/settings/ResourceTelemetryDiagnostics.tsx
+16
@@ -822,6 +822,11 @@ export function ResourceTelemetryDiagnostics({
822 },
823 environmentId,
824 );
825 + const refreshHistory = history.refresh;
826 + const selectedHistoryRef = useRef({ environmentId, windowMs, refreshHistory });
827 + useEffect(() => {
828 + selectedHistoryRef.current = { environmentId, windowMs, refreshHistory };
829 + }, [environmentId, windowMs, refreshHistory]);
830 const signalServerProcess = useAtomCommand(serverEnvironment.signalProcess, {
831 reportFailure: false,
832 });
@@ -929,6 +934,17 @@ export function ResourceTelemetryDiagnostics({
934 return;
935 setIsRetrying(true);
936 void retryTelemetry()
937 + .then(() => {
938 + refreshHistory();
939 + const selectedHistory = selectedHistoryRef.current;
940 + if (
941 + environmentIdRef.current === environmentId &&
942 + selectedHistory.environmentId === environmentId &&
943 + selectedHistory.windowMs !== windowMs
944 + ) {
945 + selectedHistory.refreshHistory();
946 + }
947 + })
948 .catch((error: unknown) => {
949 toastManager.add({
950 type: "error",
apps/web/src/lib/resourceTelemetryState.browser.test.tsx new
+266
@@ -0,0 +1,266 @@
1 +import { RegistryContext } from "@effect/atom-react";
2 +import {
3 + EnvironmentId,
4 + type ResourceTelemetryHistory,
5 + type ResourceTelemetrySnapshot,
6 +} from "@t3tools/contracts";
7 +import * as Cause from "effect/Cause";
8 +import * as DateTime from "effect/DateTime";
9 +import * as Data from "effect/Data";
10 +import * as Effect from "effect/Effect";
11 +import * as Option from "effect/Option";
12 +import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
13 +import type { ReactNode } from "react";
14 +import { describe, expect, it, vi } from "vite-plus/test";
15 +
16 +import { act, render } from "../../test/render";
17 +
18 +const monitor = vi.hoisted(() => ({
19 + telemetry:
20 + vi.fn<
21 + (args: {
22 + environmentId: EnvironmentId;
23 + }) => Atom.Atom<AsyncResult.AsyncResult<ResourceTelemetrySnapshot, MonitorError>>
24 + >(),
25 + history:
26 + vi.fn<
27 + (args: {
28 + environmentId: EnvironmentId;
29 + input: { windowMs: number; bucketMs: number };
30 + }) => Atom.Atom<AsyncResult.AsyncResult<ResourceTelemetryHistory, MonitorError>>
31 + >(),
32 + retry: vi.fn(),
33 +}));
34 +
35 +vi.mock("../components/settings/settingsLayout", () => ({
36 + SettingsSection: ({
37 + title,
38 + headerAction,
39 + children,
40 + }: {
41 + title: string;
42 + headerAction?: ReactNode;
43 + children: ReactNode;
44 + }) => (
45 + <section aria-label={title}>
46 + {headerAction}
47 + {children}
48 + </section>
49 + ),
50 +}));
51 +
52 +vi.mock("../state/environments", () => ({ usePrimaryEnvironment: () => null }));
53 +vi.mock("../state/session", () => ({
54 + readEnvironmentScope: () => true,
55 + useEnvironmentScope: () => true,
56 +}));
57 +vi.mock("../state/server", () => ({
58 + serverEnvironment: {
59 + resourceTelemetry: monitor.telemetry,
60 + resourceTelemetryHistory: monitor.history,
61 + },
62 +}));
63 +vi.mock("../state/use-atom-command", () => ({ useAtomCommand: () => monitor.retry }));
64 +
65 +import { ResourceTelemetryDiagnostics } from "../components/settings/ResourceTelemetryDiagnostics";
66 +
67 +class MonitorError extends Data.TaggedError("MonitorError")<{ readonly message: string }> {}
68 +
69 +const environmentId = EnvironmentId.make("remote");
70 +const startError = "The resource monitor is not available.";
71 +const historyError = "Resource history could not start.";
72 +
73 +function setup({ retryFails = false, holdRetry = false } = {}) {
74 + const readAt = DateTime.makeUnsafe(0);
75 + const aggregate = {
76 + processCount: 0,
77 + currentCpuPercent: 0,
78 + cpuTimeMs: 0,
79 + currentRssBytes: 0,
80 + peakRssBytes: 0,
81 + ioReadBytes: 0,
82 + ioWriteBytes: 0,
83 + ioReadBytesPerSecond: 0,
84 + ioWriteBytesPerSecond: 0,
85 + processStarts: 0,
86 + processExits: 0,
87 + };
88 + const source = {
89 + status: "healthy" as const,
90 + lastSampleAt: Option.some(readAt),
91 + lastError: Option.none<string>(),
92 + };
93 + const snapshot: ResourceTelemetrySnapshot = {
94 + readAt,
95 + sampleIntervalMs: 1000,
96 + processes: [],
97 + groups: { backend: aggregate, electron: aggregate, monitor: aggregate, allT3: aggregate },
98 + power: {
99 + source: "unknown",
100 + idle: "unknown",
101 + idleSeconds: null,
102 + locked: "unknown",
103 + suspended: false,
104 + onBattery: "unknown",
105 + lowPowerMode: "unknown",
106 + thermalState: "unknown",
107 + stale: false,
108 + updatedAt: readAt,
109 + },
110 + speedLimitPercent: Option.none(),
111 + attribution: { readAt, entries: [] },
112 + health: {
113 + native: source,
114 + desktop: source,
115 + sidecarVersion: Option.none(),
116 + sidecarPid: Option.none(),
117 + restartCount: 1,
118 + collectionDurationMicros: 0,
119 + scannedProcessCount: 0,
120 + retainedProcessCount: 0,
121 + inaccessibleProcessCount: 0,
122 + },
123 + };
124 + const history: ResourceTelemetryHistory = {
125 + readAt,
126 + windowMs: 900000,
127 + bucketMs: 30000,
128 + sampleIntervalMs: 1000,
129 + retainedSampleCount: 0,
130 + buckets: [],
131 + topProcesses: [],
132 + health: snapshot.health,
133 + };
134 + let running = false;
135 + const telemetryQueries = Atom.family((_environmentId: EnvironmentId) =>
136 + Atom.make(
137 + Effect.suspend(() =>
138 + running ? Effect.succeed(snapshot) : Effect.fail(new MonitorError({ message: startError })),
139 + ),
140 + ).pipe(Atom.keepAlive),
141 + );
142 + monitor.telemetry.mockReset();
143 + monitor.telemetry.mockImplementation(({ environmentId }) => telemetryQueries(environmentId));
144 + const historyReads = vi.fn<(key: string) => void>();
145 + const historyQueries = Atom.family((key: string) =>
146 + Atom.make(
147 + Effect.suspend(() => {
148 + historyReads(key);
149 + return running
150 + ? Effect.succeed(history)
151 + : Effect.fail(new MonitorError({ message: historyError }));
152 + }),
153 + ).pipe(Atom.keepAlive),
154 + );
155 + monitor.history.mockReset();
156 + monitor.history.mockImplementation(({ environmentId, input }) =>
157 + historyQueries(`${environmentId}:${input.windowMs}`),
158 + );
159 + let releaseRetry = () => {};
160 + const retryRelease = new Promise<void>((resolve) => {
161 + releaseRetry = resolve;
162 + });
163 + monitor.retry.mockReset();
164 + monitor.retry.mockImplementation(async () => {
165 + if (holdRetry) await retryRelease;
166 + if (retryFails)
167 + return AsyncResult.failure(Cause.fail(new MonitorError({ message: "Restart failed." })));
168 + running = true;
169 + return AsyncResult.success({ accepted: true, snapshot });
170 + });
171 + const registry = AtomRegistry.make();
172 + return {
173 + registry,
174 + historyQueries,
175 + historyReads,
176 + releaseRetry,
177 + [Symbol.dispose]: () => registry.dispose(),
178 + };
179 +}
180 +
181 +describe("resource monitor retry", () => {
182 + it("clears the settings and history errors after a successful retry without remounting", async () => {
183 + using fixture = setup();
184 + await using screen = await render(
185 + <RegistryContext.Provider value={fixture.registry}>
186 + <ResourceTelemetryDiagnostics environmentId={environmentId} />
187 + </RegistryContext.Provider>,
188 + );
189 + await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
190 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
191 +
192 + await screen.getByRole("button", { name: "Retry monitor" }).click();
193 +
194 + await expect.element(screen.getByText(startError, { exact: true })).not.toBeInTheDocument();
195 + await expect.element(screen.getByText(historyError, { exact: true })).not.toBeInTheDocument();
196 + await expect.element(screen.getByText("Native healthy", { exact: true })).toBeVisible();
197 + await expect
198 + .element(screen.getByRole("button", { name: "Retry monitor" }))
199 + .not.toBeInTheDocument();
200 + });
201 +
202 + it.each([false, true])(
203 + "refreshes the changed history window only in the retry environment (switch environment: %s)",
204 + async (switchEnvironment) => {
205 + using fixture = setup({ holdRetry: true });
206 + const view = (selectedEnvironment: EnvironmentId) => (
207 + <RegistryContext.Provider value={fixture.registry}>
208 + <ResourceTelemetryDiagnostics environmentId={selectedEnvironment} />
209 + </RegistryContext.Provider>
210 + );
211 + await using screen = await render(view(environmentId));
212 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
213 + await screen.getByRole("button", { name: "Retry monitor" }).click();
214 + await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeDisabled();
215 + const selectedEnvironment = switchEnvironment ? EnvironmentId.make("other") : environmentId;
216 + if (switchEnvironment) await screen.rerender(view(selectedEnvironment));
217 + await screen.getByRole("button", { name: "5m", exact: true }).click();
218 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
219 + const selectedKey = `${selectedEnvironment}:300000`;
220 + expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Failure");
221 + fixture.historyReads.mockClear();
222 +
223 + await act(() => fixture.releaseRetry());
224 +
225 + if (switchEnvironment) {
226 + await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeEnabled();
227 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
228 + expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Failure");
229 + expect(fixture.historyReads).not.toHaveBeenCalled();
230 + } else {
231 + await expect.element(screen.getByText(startError, { exact: true })).not.toBeInTheDocument();
232 + await expect
233 + .element(screen.getByText(historyError, { exact: true }))
234 + .not.toBeInTheDocument();
235 + expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Success");
236 + expect(fixture.historyReads.mock.calls.map(([key]) => key)).toEqual([selectedKey]);
237 + await screen.getByRole("button", { name: "15m", exact: true }).click();
238 + await expect
239 + .element(screen.getByText(historyError, { exact: true }))
240 + .not.toBeInTheDocument();
241 + }
242 + expect(fixture.registry.get(fixture.historyQueries(`${environmentId}:900000`))._tag).toBe(
243 + "Success",
244 + );
245 + expect(monitor.retry).toHaveBeenCalledExactlyOnceWith({ environmentId, input: {} });
246 + },
247 + );
248 +
249 + it("keeps the failed monitor and history errors visible when retry fails", async () => {
250 + using fixture = setup({ retryFails: true });
251 + await using screen = await render(
252 + <RegistryContext.Provider value={fixture.registry}>
253 + <ResourceTelemetryDiagnostics environmentId={environmentId} />
254 + </RegistryContext.Provider>,
255 + );
256 + await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
257 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
258 +
259 + await screen.getByRole("button", { name: "Retry monitor" }).click();
260 +
261 + await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeEnabled();
262 + expect(monitor.retry).toHaveBeenCalledExactlyOnceWith({ environmentId, input: {} });
263 + await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
264 + await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
265 + });
266 +});
apps/web/src/lib/resourceTelemetryState.ts
+1
@@ -52,6 +52,7 @@ export function useResourceTelemetry(
52 if (result._tag === "Failure") {
53 throw Cause.squash(result.cause);
54 }
55 + query.refresh();
56 return result.value.snapshot;
57 };
58