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

main
tsx 502 lines 17.2 KB
Raw
1 import "~/index.css";
2 import * as DateTime from "effect/DateTime";
3 import { EnvironmentId, NodeId, ThreadId } from "@t3tools/contracts";
4 import * as Cause from "effect/Cause";
5 import { AsyncResult } from "effect/reactivity";
6 import { expect, it, vi } from "vite-plus/test";
7 import { page, userEvent } from "vite-plus/test/browser";
8
9 import "~/index.css";
10
11 const state = vi.hoisted(() => ({
12 projection: null as unknown,
13 commandSucceeds: false,
14 relatedShells: [] as unknown[],
15 threadTitles: {} as Record<string, string>,
16 archivedThreads: [] as unknown[],
17 }));
18
19 vi.mock(import("../../state/query"), async (original) => ({
20 ...(await original()),
21 useEnvironmentQuery: ((atom: unknown) =>
22 atom === null
23 ? { data: null, isSuccess: false, isPending: false }
24 : { data: state.threadTitles, isSuccess: true, isPending: false }) as never,
25 }));
26
27 vi.mock(import("@effect/atom-react"), async (original) => ({
28 ...(await original()),
29 useAtomValue: (() => false) as never,
30 }));
31
32 vi.mock(import("../../state/entities"), () => ({
33 useQuietThreadShell: (() => null) as never,
34 useQuietThreadProjection: ((ref: unknown) =>
35 ref === null ? null : { projection: state.projection }) as never,
36 useThreadRelationshipShells: (() =>
37 state.projection === null
38 ? []
39 : [(state.projection as { thread: unknown }).thread, ...state.relatedShells]) as never,
40 useProjects: (() => []) as never,
41 useHiddenThreadKeys: (() => new Set()) as never,
42 useAnyEnvironmentHiding: (() => false) as never,
43 }));
44 vi.mock(import("../../state/environments"), () => ({
45 // The click rule reads the client setting, whose module asks for these.
46 useEnvironments: (() => []) as never,
47 usePrimaryEnvironment: (() => null) as never,
48 useEnvironment: (() => null) as never,
49 useEnvironmentProviders: (() => new Map()) as never,
50 }));
51 vi.mock(import("../../state/peerLinks"), () => ({
52 peerLinkEnvironment: { readThread: {} } as never,
53 useLinkedEnvironments: (() => new Map()) as never,
54 }));
55 vi.mock(import("../../lib/archivedThreadsState"), () => ({
56 useArchivedThreadSnapshots: (() => ({
57 snapshots: [{ environmentId: "environment", snapshot: { threads: state.archivedThreads } }],
58 })) as never,
59 }));
60 vi.mock(import("../../state/use-atom-command"), () => ({
61 useAtomCommand: (() => async () =>
62 state.commandSucceeds
63 ? AsyncResult.success(undefined)
64 : AsyncResult.failure(Cause.fail(new Error("Connection lost")))) as never,
65 }));
66
67 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
68
69 import { render } from "../../../test/render";
70 import { isMacPlatform } from "../../lib/utils";
71 import { selectThreadRightPanelState, useRightPanelStore } from "../../rightPanelStore";
72 import { makeThreadProjectionFixture } from "../../test-fixtures";
73 import { ScrollArea } from "../ui/scroll-area";
74 import { ToastProvider } from "../ui/toast";
75 import { ThreadRelationshipsPanel } from "./ThreadRelationshipsControl";
76
77 const environmentId = EnvironmentId.make("environment");
78 const threadId = ThreadId.make("fork");
79
80 function setup() {
81 useRightPanelStore.setState(useRightPanelStore.getInitialState());
82 state.commandSucceeds = false;
83 state.relatedShells = [];
84 state.threadTitles = { source: "Source" };
85 state.archivedThreads = [];
86 state.projection = {
87 thread: {
88 id: threadId,
89 title: "Fork",
90 activeProviderThreadId: null,
91 lineage: { parentThreadId: ThreadId.make("source"), relationshipToParent: "fork" },
92 forkedFrom: null,
93 },
94 runs: [{ id: "run", ordinal: 1, status: "completed" }],
95 subagents: [],
96 contextTransfers: [],
97 providerThreads: [],
98 providerSessions: [{ id: "session", status: "ready" }],
99 };
100 }
101
102 it.each([
103 ["merge", "Could not merge back"],
104 ["disconnect", "Could not disconnect agent session"],
105 ])("reports a rejected %s command and clears the busy state", async (action, title) => {
106 setup();
107 await using screen = await render(
108 <ToastProvider timeout={0}>
109 <ThreadRelationshipsPanel
110 environmentId={environmentId}
111 threadId={threadId}
112 showLineage
113 showSideChats
114 />
115 </ToastProvider>,
116 );
117
118 if (action === "merge") {
119 await screen.getByRole("button", { name: "Merge back to source conversation" }).click();
120 } else {
121 await screen.getByRole("button", { name: "More thread actions" }).click();
122 await page.getByRole("menuitem", { name: "Disconnect agent session" }).click();
123 }
124
125 await expect.element(page.getByText(title, { exact: true })).toBeVisible();
126 await expect
127 .element(
128 screen.getByRole("button", {
129 name: action === "merge" ? "Merge back to source conversation" : "More thread actions",
130 }),
131 )
132 .toBeEnabled();
133 });
134
135 it.each([
136 ["merge", "Could not merge back"],
137 ["disconnect", "Could not disconnect agent session"],
138 ])("clears the previous %s error after a successful retry", async (action, title) => {
139 setup();
140 await using screen = await render(
141 <ToastProvider timeout={0}>
142 <ThreadRelationshipsPanel
143 environmentId={environmentId}
144 threadId={threadId}
145 showLineage
146 showSideChats
147 />
148 </ToastProvider>,
149 { router: "/environment/fork" },
150 );
151
152 const runAction = async () => {
153 if (action === "merge") {
154 await screen.getByRole("button", { name: "Merge back to source conversation" }).click();
155 } else {
156 await screen.getByRole("button", { name: "More thread actions" }).click();
157 await page.getByRole("menuitem", { name: "Disconnect agent session" }).click();
158 }
159 };
160
161 await runAction();
162 await expect.element(page.getByText(title, { exact: true })).toBeVisible();
163 expect(screen.router?.state.location.pathname).toBe("/environment/fork");
164
165 state.commandSucceeds = true;
166 await runAction();
167
168 await expect.element(page.getByText(title, { exact: true })).not.toBeInTheDocument();
169 await vi.waitFor(() => {
170 expect(screen.router?.state.location.pathname).toBe(
171 action === "merge" ? "/environment/source" : "/environment/fork",
172 );
173 });
174 if (action === "disconnect") {
175 await expect.element(screen.getByRole("button", { name: "More thread actions" })).toBeEnabled();
176 }
177 });
178
179 it("opens an idle child beside the thread, and in its place with the modifier", async () => {
180 setup();
181 const projection = makeThreadProjectionFixture();
182 const childId = ThreadId.make("omitted-child");
183 const environmentId = EnvironmentId.make("local");
184 state.projection = {
185 ...projection,
186 subagents: [
187 {
188 id: NodeId.make("agent"),
189 threadId: projection.thread.id,
190 runId: null,
191 parentNodeId: NodeId.make("parent"),
192 origin: "app_owned",
193 createdBy: "agent",
194 driver: "codex",
195 providerInstanceId: projection.thread.providerInstanceId,
196 providerThreadId: null,
197 childThreadId: childId,
198 nativeTaskRef: null,
199 prompt: "Inspect the change",
200 title: "Idle child",
201 model: null,
202 status: "completed",
203 result: null,
204 startedAt: null,
205 completedAt: projection.thread.updatedAt,
206 updatedAt: projection.thread.updatedAt,
207 },
208 ],
209 };
210 await using screen = await render(
211 <ThreadRelationshipsPanel
212 environmentId={environmentId}
213 threadId={projection.thread.id}
214 showLineage
215 showSideChats
216 />,
217 );
218 await screen.getByRole("button", { name: /Previous agents/ }).click();
219 const child = screen.getByRole("button", { name: /Idle child/ });
220 await expect.element(child).toBeEnabled();
221 const panelRef = scopeThreadRef(environmentId, projection.thread.id);
222 const panel = () =>
223 selectThreadRightPanelState(useRightPanelStore.getState().byThreadKey, panelRef);
224 await child.click();
225 expect(panel()).toMatchObject({
226 isOpen: true,
227 activeSurfaceId: "thread:omitted-child",
228 surfaces: [{ kind: "thread", threadId: childId }],
229 });
230 expect(screen.router?.state.location.pathname).toBe("/");
231 // Idle children can be omitted from the shell; the route loads the child's own detail.
232 await child.click({ modifiers: [isMacPlatform(navigator.platform) ? "Meta" : "Control"] });
233 await vi.waitFor(() =>
234 expect(screen.router?.state.location.pathname).toBe("/local/omitted-child"),
235 );
236 expect(panel().surfaces).toHaveLength(1);
237 });
238
239 it("shows a lineage thread's full title in its tooltip", async () => {
240 setup();
241 const longTitle = "Compare the lineage tooltip against a title that the row truncates";
242 const sourceThread = {
243 ...(state.projection as { thread: Record<string, unknown> }).thread,
244 id: "source",
245 title: longTitle,
246 lineage: { parentThreadId: null, relationshipToParent: null },
247 };
248 state.relatedShells = [sourceThread];
249 await using _screen = await render(
250 <ThreadRelationshipsPanel
251 environmentId={environmentId}
252 threadId={threadId}
253 showLineage
254 showSideChats={false}
255 />,
256 );
257
258 await userEvent.hover(page.getByText(longTitle, { exact: true }));
259 await vi.waitFor(() =>
260 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(longTitle),
261 );
262 });
263
264 it("shows a side chat's full title in its tooltip", async () => {
265 setup();
266 const longTitle = "Side chat question with a title that the side chat row truncates";
267 state.relatedShells = [
268 {
269 id: "side",
270 title: longTitle,
271 lineage: {
272 parentThreadId: threadId,
273 relationshipToParent: "fork",
274 rootThreadId: threadId,
275 sideChat: true,
276 },
277 },
278 ];
279 await using _screen = await render(
280 <ThreadRelationshipsPanel
281 environmentId={environmentId}
282 threadId={threadId}
283 showLineage={false}
284 showSideChats
285 />,
286 );
287
288 await userEvent.hover(page.getByText(longTitle, { exact: true }));
289 await vi.waitFor(() =>
290 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(longTitle),
291 );
292 });
293
294 it("shows a remote subagent's full title in its tooltip even when its environment is unavailable", async () => {
295 setup();
296 const longTitle = "Investigate a remote subagent issue across linked environments";
297 const remoteEnvId = EnvironmentId.make("remote-env");
298 const remoteThreadId = ThreadId.make("remote-thread");
299 const now = DateTime.makeUnsafe("2026-10-31T20:00:00.000Z");
300 state.projection = {
301 ...(state.projection as Record<string, unknown>),
302 subagents: [
303 {
304 id: NodeId.make("remote-agent"),
305 threadId,
306 runId: null,
307 parentNodeId: NodeId.make("parent"),
308 origin: "app_owned",
309 createdBy: "agent",
310 driver: "codex",
311 providerInstanceId: "provider",
312 providerThreadId: null,
313 childThreadId: null,
314 nativeTaskRef: null,
315 prompt: "Run remote task",
316 title: longTitle,
317 model: null,
318 status: "completed",
319 result: null,
320 startedAt: null,
321 completedAt: null,
322 updatedAt: now,
323 remoteChild: {
324 environmentId: remoteEnvId,
325 threadId: remoteThreadId,
326 label: "Remote VM with a long machine name in the office",
327 },
328 },
329 ],
330 };
331 await using screen = await render(
332 <div style={{ width: 320 }}>
333 <ThreadRelationshipsPanel
334 environmentId={environmentId}
335 threadId={threadId}
336 showLineage
337 showSideChats={false}
338 />
339 </div>,
340 { router: "/environment/fork" },
341 );
342
343 // A finished remote task sits with the other finished agents, not in its own list.
344 await expect
345 .element(screen.getByRole("button", { name: new RegExp(longTitle) }))
346 .not.toBeInTheDocument();
347 await screen.getByRole("button", { name: /Previous agents/ }).click();
348 const row = screen.getByRole("button", { name: new RegExp(longTitle) });
349 // A long environment label must not squeeze the title out of the row.
350 expect(
351 page.getByText(longTitle, { exact: true }).element().getBoundingClientRect().width,
352 ).toBeGreaterThan(0);
353 await userEvent.hover(row);
354 await vi.waitFor(() =>
355 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(longTitle),
356 );
357 // This client is not connected there, so the row reads the thread through this environment.
358 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(
359 "Read the thread on Remote VM with a long machine name in the office",
360 );
361
362 await row.click({ force: true });
363 expect(screen.router?.state.location.pathname).toBe("/environment/fork");
364 });
365
366 it("explains why Merge back is unavailable before the fork completes a run", async () => {
367 setup();
368 state.projection = { ...(state.projection as Record<string, unknown>), runs: [] };
369 await using screen = await render(
370 <ThreadRelationshipsPanel
371 environmentId={environmentId}
372 threadId={threadId}
373 showLineage
374 showSideChats={false}
375 />,
376 { router: "/environment/fork" },
377 );
378
379 const mergeBack = screen.getByRole("button", { name: "Merge back to source conversation" });
380 await userEvent.hover(mergeBack);
381 await vi.waitFor(() =>
382 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toBe(
383 "Complete a run in this fork before merging it back",
384 ),
385 );
386
387 state.commandSucceeds = true;
388 await mergeBack.click({ force: true });
389 expect(screen.router?.state.location.pathname).toBe("/environment/fork");
390 });
391
392 it("shows a delegated-from thread's full title in its tooltip even when its environment is unavailable", async () => {
393 setup();
394 const longTitle = "Parent task delegated from another machine that has a long description";
395 state.projection = {
396 ...(state.projection as Record<string, unknown>),
397 thread: {
398 ...(state.projection as { thread: Record<string, unknown> }).thread,
399 delegatedFrom: {
400 environmentId: EnvironmentId.make("parent-env"),
401 threadId: ThreadId.make("parent-thread"),
402 title: longTitle,
403 },
404 },
405 };
406 await using screen = await render(
407 <ThreadRelationshipsPanel
408 environmentId={environmentId}
409 threadId={threadId}
410 showLineage
411 showSideChats={false}
412 />,
413 { router: "/environment/fork" },
414 );
415
416 const row = screen.getByRole("button", { name: new RegExp(longTitle) });
417 await userEvent.hover(row);
418 await vi.waitFor(() =>
419 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(longTitle),
420 );
421 expect(document.querySelector('[data-slot="tooltip-popup"]')?.textContent).toContain(
422 "Delegated from a linked environment. Connect to it to open the parent thread.",
423 );
424
425 await row.click({ force: true });
426 expect(screen.router?.state.location.pathname).toBe("/environment/fork");
427 });
428
429 it("hides a deleted fork and keeps unloaded and archived forks with their current titles", async () => {
430 setup();
431 const projection = makeThreadProjectionFixture();
432 state.threadTitles = { "unloaded-fork": "Unloaded fork", "archived-fork": "Archived fork" };
433 state.archivedThreads = [
434 {
435 ...projection.thread,
436 id: ThreadId.make("archived-fork"),
437 title: "Old archived title",
438 archivedAt: projection.thread.updatedAt,
439 lineage: { parentThreadId: projection.thread.id, relationshipToParent: "fork" },
440 },
441 ];
442 state.projection = {
443 ...projection,
444 contextTransfers: ["deleted-fork", "unloaded-fork", "archived-fork"].map((id) => ({
445 sourceThreadId: projection.thread.id,
446 targetThreadId: ThreadId.make(id),
447 status: "pending",
448 })),
449 };
450 await using screen = await render(
451 <ThreadRelationshipsPanel
452 environmentId={environmentId}
453 threadId={projection.thread.id}
454 showLineage
455 showSideChats
456 />,
457 );
458 await expect.element(screen.getByText("Unloaded fork", { exact: true })).toBeVisible();
459 await expect.element(screen.getByText("Archived fork", { exact: true })).toBeVisible();
460 await expect.element(screen.getByText("deleted-fork", { exact: true })).not.toBeInTheDocument();
461 });
462
463 it.each([1, 18])("continues scrolling the panel past a list of %i subagents", async (count) => {
464 setup();
465 const projection = makeThreadProjectionFixture();
466 state.projection = projection;
467 state.relatedShells = Array.from({ length: count }, (_, index) => ({
468 id: ThreadId.make(`subagent-${index}`),
469 title: `Subagent ${index}`,
470 forkedFrom: null,
471 lineage: { parentThreadId: projection.thread.id, relationshipToParent: "subagent" },
472 activityRunStatus: "running",
473 status: "running",
474 }));
475 await using screen = await render(
476 <div data-testid="panel" style={{ height: 320, width: 280 }}>
477 <ScrollArea>
478 <ThreadRelationshipsPanel
479 environmentId={environmentId}
480 threadId={projection.thread.id}
481 showLineage
482 showSideChats
483 />
484 <div style={{ height: 600 }} />
485 </ScrollArea>
486 </div>,
487 );
488 if (count > 6) {
489 await screen.getByRole("button", { name: "Show 12 more" }).click();
490 await expect.element(screen.getByText("Subagent 17", { exact: true })).toBeInTheDocument();
491 }
492 const list = screen.getByRole("list", { name: "Related threads" }).element();
493 const viewport = screen
494 .getByTestId("panel")
495 .element()
496 .querySelector<HTMLElement>("[data-slot=scroll-area-viewport]")!;
497 list.scrollTop = list.scrollHeight;
498 if (count > 6) expect(list.scrollTop).toBeGreaterThan(0);
499 viewport.scrollTop = 0;
500 await userEvent.wheel(list, { delta: { y: 300 } });
501 await vi.waitFor(() => expect(viewport.scrollTop).toBeGreaterThan(0));
502 });