@devries-cameron20 / t3code-1 / commits / 930df19f2a
Fork 0

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

fix(mobile): release hidden sidebar PR summary demand (#25337)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: maria-rcks <maria@kuuro.net> Co-authored-by: maria-rcks <254055478+maria-rcks@users.noreply.github.com>

Alex Southwell committed Oct 30, 2026 at 21:52 UTC 930df19f2a6e79511a784cd7af43ed3ba61bd200
5 files changed +376 -6
apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
+10 -4
@@ -74,6 +74,7 @@ import {
74 } from "./thread-list-v2-items";
75 import { useThreadRowProviderInstanceResolver } from "./thread-provider-instance";
76 import type { ThreadPrPresentation } from "../../state/thread-pr-presentation";
77 +import { ThreadPrDemandProvider } from "../../state/thread-pr-demand";
78 import {
79 isThreadListV2ListItem,
80 threadListV2ListItemsAreEqual,
@@ -115,10 +116,15 @@ interface ThreadNavigationSidebarProps {
116 }
117
118 export function ThreadNavigationSidebar(props: ThreadNavigationSidebarProps) {
118 - if (Platform.OS !== "ios") {
119 - return <ThreadNavigationSidebarPane {...props} nativeChrome={false} />;
120 - }
121 - return <NativeSidebarContainer {...props} />;
119 + return (
120 + <ThreadPrDemandProvider visible={props.visible}>
121 + {Platform.OS !== "ios" ? (
122 + <ThreadNavigationSidebarPane {...props} nativeChrome={false} />
123 + ) : (
124 + <NativeSidebarContainer {...props} />
125 + )}
126 + </ThreadPrDemandProvider>
127 + );
128 }
129
130 function NativeSidebarContainer(props: ThreadNavigationSidebarProps) {
apps/mobile/src/state/thread-pr-demand.tsx new
+16
@@ -0,0 +1,16 @@
1 +import { createContext, type ReactNode } from "react";
2 +
3 +import { useAppActive } from "../lib/appState";
4 +
5 +export const ThreadPrDemandContext = createContext(true);
6 +
7 +export function ThreadPrDemandProvider(props: {
8 + readonly visible: boolean;
9 + readonly children: ReactNode;
10 +}) {
11 + const active = useAppActive();
12 + // A sidebar can stay visible beside a focused detail route, so route focus cannot gate its reads.
13 + return (
14 + <ThreadPrDemandContext value={props.visible && active}>{props.children}</ThreadPrDemandContext>
15 + );
16 +}
apps/mobile/src/state/use-thread-pr.demand.test.tsx new
+345
@@ -0,0 +1,345 @@
1 +import { RegistryContext } from "@effect/atom-react";
2 +import {
3 + EnvironmentId,
4 + ProjectId,
5 + ThreadId,
6 + WS_METHODS,
7 + type PullRequestRef,
8 +} from "@t3tools/contracts";
9 +import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
10 +import {
11 + EnvironmentRegistry,
12 + EnvironmentSupervisor,
13 + AVAILABLE_CONNECTION_STATE,
14 + PrimaryConnectionTarget,
15 + type SupervisorConnectionState,
16 + type PreparedConnection,
17 + type ConnectionCatalogEntry,
18 +} from "@t3tools/client-runtime/connection";
19 +import type { RpcSession } from "@t3tools/client-runtime/rpc";
20 +import * as Effect from "effect/Effect";
21 +import * as Latch from "effect/Latch";
22 +import * as Option from "effect/Option";
23 +import * as Stream from "effect/Stream";
24 +import * as SubscriptionRef from "effect/SubscriptionRef";
25 +import { AtomRegistry } from "effect/reactivity";
26 +import { Activity, act, useState } from "react";
27 +import { createRoot } from "react-dom/client";
28 +import { expect, it } from "@effect/vitest";
29 +import { vi } from "vite-plus/test";
30 +
31 +const fixture = vi.hoisted(() => ({
32 + environment: undefined as EnvironmentRegistry.EnvironmentRegistry["Service"] | undefined,
33 + active: "active",
34 + listeners: new Set<() => void>(),
35 +}));
36 +
37 +vi.mock("react-native", () => ({
38 + AppState: {
39 + get currentState() {
40 + return fixture.active;
41 + },
42 + addEventListener: (_event: string, listener: () => void) => {
43 + fixture.listeners.add(listener);
44 + return { remove: () => fixture.listeners.delete(listener) };
45 + },
46 + },
47 +}));
48 +vi.mock("../connection/runtime", async () => {
49 + const { Atom } = await import("effect/reactivity");
50 + const Layer = await import("effect/Layer");
51 + const { EnvironmentRegistry } = await import("@t3tools/client-runtime/connection");
52 + return {
53 + connectionAtomRuntime: Atom.runtime(
54 + Layer.suspend(() =>
55 + Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, fixture.environment!),
56 + ),
57 + ),
58 + };
59 +});
60 +vi.mock("./server", async () => {
61 + const { Atom } = await import("effect/reactivity");
62 + const config = Atom.make({ environment: { capabilities: { threadPullRequests: true } } });
63 + return { serverEnvironment: { configValueAtom: () => config } };
64 +});
65 +
66 +import { ThreadPrDemandProvider } from "./thread-pr-demand";
67 +import { useThreadPr } from "./use-thread-pr";
68 +
69 +const environmentId = EnvironmentId.make("sidebar-environment");
70 +const reference = {
71 + projectId: ProjectId.make("project"),
72 + repository: "acme/app",
73 + number: 12,
74 + url: "https://github.com/acme/app/pull/12",
75 +};
76 +function thread(overrides: Partial<EnvironmentThreadShell> = {}): EnvironmentThreadShell {
77 + return {
78 + environmentId,
79 + id: ThreadId.make("thread"),
80 + pullRequests: [],
81 + linkedPullRequest: null,
82 + branchPullRequest: reference,
83 + ...overrides,
84 + } as EnvironmentThreadShell;
85 +}
86 +
87 +const setup = Effect.fn("TestThreadPr.setup")(function* () {
88 + (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
89 + vi.useFakeTimers({
90 + toFake: ["Date", "setTimeout", "clearTimeout", "setInterval", "clearInterval"],
91 + });
92 + vi.setSystemTime(0);
93 + fixture.active = "active";
94 + fixture.listeners.clear();
95 + const requests: Array<{ environmentId: EnvironmentId; input: PullRequestRef }> = [];
96 + let state = "open";
97 + let replyGate: Latch.Latch | null = null;
98 + const target = new PrimaryConnectionTarget({
99 + environmentId,
100 + label: "Sidebar environment",
101 + httpBaseUrl: "https://sidebar.test",
102 + wsBaseUrl: "wss://sidebar.test",
103 + });
104 + const supervisor = yield* Effect.gen(function* () {
105 + return EnvironmentSupervisor.EnvironmentSupervisor.of({
106 + target,
107 + state: yield* SubscriptionRef.make<SupervisorConnectionState>({
108 + ...AVAILABLE_CONNECTION_STATE,
109 + phase: "connected" as const,
110 + desired: true,
111 + network: "online" as const,
112 + attempt: 1,
113 + generation: 1,
114 + }),
115 + session: yield* SubscriptionRef.make(
116 + Option.some({
117 + client: {
118 + [WS_METHODS.pullRequestsSummary]: (input: PullRequestRef) =>
119 + Effect.gen(function* () {
120 + requests.push({ environmentId: currentEnvironment, input });
121 + if (replyGate !== null) yield* replyGate.await;
122 + return {
123 + ...input,
124 + provider: "github",
125 + state,
126 + title: `Change ${input.number}`,
127 + url: `https://github.com/${input.repository}/pull/${input.number}`,
128 + baseBranch: "main",
129 + headBranch: "feature",
130 + isDraft: false,
131 + updatedAt: null,
132 + };
133 + }),
134 + [WS_METHODS.pullRequestsSubscribeRefreshes]: () => Stream.never,
135 + },
136 + ready: Effect.void,
137 + } as unknown as RpcSession),
138 + ),
139 + prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
140 + connect: Effect.void,
141 + disconnect: Effect.void,
142 + retryNow: Effect.void,
143 + });
144 + });
145 + let currentEnvironment = environmentId;
146 + const environment = {
147 + entries: yield* SubscriptionRef.make<ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>>(
148 + new Map(),
149 + ),
150 + run: (id, effect) => {
151 + currentEnvironment = id;
152 + return Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
153 + },
154 + followStream: (_id, stream) =>
155 + Stream.provideService(stream, EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
156 + stateChanges: () => SubscriptionRef.changes(supervisor.state),
157 + } satisfies Pick<
158 + EnvironmentRegistry.EnvironmentRegistry["Service"],
159 + "entries" | "run" | "followStream" | "stateChanges"
160 + >;
161 + fixture.environment =
162 + environment as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"];
163 + const registry = AtomRegistry.make();
164 + const container = document.createElement("div");
165 + const root = createRoot(container);
166 + let mounts = 0;
167 + function Row({ value, name }: { value: EnvironmentThreadShell; name: string }) {
168 + const [passive] = useState(() => ++mounts);
169 + const pr = useThreadPr(value);
170 + return (
171 + <output data-name={name} data-passive={passive}>
172 + {pr?.accessibilityLabel ?? "none"}
173 + </output>
174 + );
175 + }
176 + return {
177 + requests,
178 + get mounts() {
179 + return mounts;
180 + },
181 + setState(next: string) {
182 + state = next;
183 + },
184 + holdReplies() {
185 + replyGate = Latch.makeUnsafe();
186 + },
187 + async releaseReplies() {
188 + await act(async () => {
189 + replyGate?.openUnsafe();
190 + replyGate = null;
191 + });
192 + },
193 + badge(name = "sidebar") {
194 + return container.querySelector(`output[data-name="${name}"]`)?.textContent;
195 + },
196 + passive() {
197 + return container.querySelector("output")?.getAttribute("data-passive");
198 + },
199 + async render({
200 + visible = true,
201 + value = thread(),
202 + shared = false,
203 + activity = "visible",
204 + }: {
205 + visible?: boolean;
206 + value?: EnvironmentThreadShell;
207 + shared?: boolean;
208 + activity?: "visible" | "hidden";
209 + } = {}) {
210 + await act(async () =>
211 + root.render(
212 + <RegistryContext value={registry}>
213 + <Activity mode={activity}>
214 + <div hidden={!visible} style={{ width: 320 }}>
215 + <ThreadPrDemandProvider visible={visible}>
216 + <Row value={value} name="sidebar" />
217 + </ThreadPrDemandProvider>
218 + </div>
219 + </Activity>
220 + {shared ? <Row value={thread({ id: ThreadId.make("shared") })} name="shared" /> : null}
221 + </RegistryContext>,
222 + ),
223 + );
224 + },
225 + async advance(ms: number) {
226 + await act(async () => vi.advanceTimersByTimeAsync(ms));
227 + },
228 + async appState(next: string) {
229 + await act(async () => {
230 + fixture.active = next;
231 + for (const listener of fixture.listeners) listener();
232 + });
233 + },
234 + [Symbol.dispose]() {
235 + act(() => root.unmount());
236 + registry.dispose();
237 + expect(fixture.listeners.size).toBe(0);
238 + vi.useRealTimers();
239 + },
240 + };
241 +});
242 +
243 +it.effect(
244 + "releases retained hidden sidebar demand and keeps the badge while reveal revalidates",
245 + () =>
246 + Effect.gen(function* () {
247 + using h = yield* setup();
248 + yield* Effect.promise(async () => {
249 + await h.render();
250 + expect(h.badge()).toBe("#12 pull request open");
251 + const passive = h.passive();
252 + expect(h.requests).toHaveLength(1);
253 + await h.render({ visible: false });
254 + await h.advance(10_000);
255 + const afterGrace = h.requests.length;
256 + await h.advance(180_000);
257 + expect(h.requests.length - afterGrace).toBe(0);
258 + expect(h.passive()).toBe(passive);
259 + h.holdReplies();
260 + h.setState("closed");
261 + await h.render();
262 + expect(h.badge()).toBe("#12 pull request open");
263 + expect(h.requests.length).toBe(afterGrace + 1);
264 + expect(h.mounts).toBe(1);
265 + await h.releaseReplies();
266 + expect(h.badge()).toBe("#12 pull request closed");
267 + });
268 + }),
269 +);
270 +
271 +it.effect("does not start a fallback query for a sidebar first mounted hidden", () =>
272 + Effect.gen(function* () {
273 + using h = yield* setup();
274 + yield* Effect.promise(async () => {
275 + await h.render({ visible: false });
276 + await h.advance(180_000);
277 + expect(h.requests).toHaveLength(0);
278 + expect(h.badge()).toBe("none");
279 + await h.render();
280 + expect(h.requests).toHaveLength(1);
281 + expect(h.badge()).toBe("#12 pull request open");
282 + expect(h.mounts).toBe(1);
283 + });
284 + }),
285 +);
286 +
287 +it.effect("keeps a shared visible reader polling while its sidebar reader is hidden", () =>
288 + Effect.gen(function* () {
289 + using h = yield* setup();
290 + yield* Effect.promise(async () => {
291 + await h.render({ shared: true });
292 + expect(h.requests).toHaveLength(1);
293 + await h.render({ visible: false, shared: true });
294 + await h.advance(180_000);
295 + expect(h.requests).toHaveLength(4);
296 + expect(h.badge("shared")).toBe("#12 pull request open");
297 + h.setState("closed");
298 + await h.advance(60_000);
299 + expect(h.requests).toHaveLength(5);
300 + expect(h.badge("shared")).toBe("#12 pull request closed");
301 + await h.render({ shared: true });
302 + expect(h.badge()).toBe("#12 pull request closed");
303 + });
304 + }),
305 +);
306 +
307 +it.effect.each(["inactive", "background"])("releases sidebar demand while the OS is %s", (state) =>
308 + Effect.gen(function* () {
309 + using h = yield* setup();
310 + yield* Effect.promise(async () => {
311 + await h.render();
312 + await h.appState(state);
313 + await h.advance(10_000);
314 + const before = h.requests.length;
315 + await h.advance(180_000);
316 + expect(h.requests.length - before).toBe(0);
317 + h.holdReplies();
318 + await h.appState("active");
319 + expect(h.badge()).toBe("#12 pull request open");
320 + expect(h.requests.length - before).toBe(1);
321 + expect(h.mounts).toBe(1);
322 + });
323 + }),
324 +);
325 +
326 +it.effect("keeps mounted passive state through an Android-style Activity tab switch", () =>
327 + Effect.gen(function* () {
328 + using h = yield* setup();
329 + yield* Effect.promise(async () => {
330 + await h.render();
331 + const passive = h.passive();
332 + await h.render({ activity: "hidden" });
333 + await h.advance(10_000);
334 + const before = h.requests.length;
335 + await h.advance(180_000);
336 + expect(h.requests.length - before).toBe(0);
337 + h.holdReplies();
338 + await h.render();
339 + expect(h.badge()).toBe("#12 pull request open");
340 + expect(h.passive()).toBe(passive);
341 + expect(h.mounts).toBe(1);
342 + expect(h.requests.length - before).toBe(1);
343 + });
344 + }),
345 +);
apps/mobile/src/state/use-thread-pr.ts
+4 -2
@@ -7,11 +7,12 @@ import {
7 import type { EnvironmentId, PullRequestSummary } from "@t3tools/contracts";
8 import * as Effect from "effect/Effect";
9 import { Atom } from "effect/reactivity";
10 -import { useMemo } from "react";
10 +import { use, useMemo } from "react";
11
12 import { connectionAtomRuntime } from "../connection/runtime";
13 import { serverEnvironment } from "./server";
14 import { useEnvironmentQuery } from "./query";
15 +import { ThreadPrDemandContext } from "./thread-pr-demand";
16 import {
17 rememberBounded,
18 resolveThreadPrSource,
@@ -59,6 +60,7 @@ const pullRequestSummaryAtom = createLinkedPullRequestSummaryAtomFamily(
60 export { type ThreadPr, type ThreadPrPresentation } from "./thread-pr-presentation";
61
62 export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentation | null {
63 + const demand = use(ThreadPrDemandContext);
64 const supportsLinks = useAtomValue(
65 serverEnvironment.configValueAtom(thread.environmentId),
66 (config) => config !== null,
@@ -81,7 +83,7 @@ export function useThreadPr(thread: EnvironmentThreadShell): ThreadPrPresentatio
83 key === null ? undefined : current.get(key),
84 );
85 const pullRequestSummary = useEnvironmentQuery(
84 - pullRequestRef === null
86 + pullRequestRef === null || !demand
87 ? null
88 : pullRequestSummaryAtom({
89 environmentId: thread.environmentId,
apps/mobile/vite.config.ts
+1
@@ -5,6 +5,7 @@ import "vite-plus/test/config";
5
6 const reactTests = [
7 "src/features/workspace/workspace-tabs-state.test.ts",
8 + "src/state/use-thread-pr.demand.test.tsx",
9 "src/features/threads/git/GitBranchesSheet.occupancy.test.tsx",
10 "src/features/files/useFileTreeEntries.test.tsx",
11 "src/features/projects/AddProjectScreen.test.ts",