@devries-cameron20 / t3code Mirror · read-only
Fork 0

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 21, 03:37 UTC

main
ts 293 lines 11.3 KB
Raw
1 import { scopeThreadRef, scopedThreadKey } from "@t3tools/client-runtime/environment";
2 import { ThreadId } from "@t3tools/contracts";
3 import { beforeEach, describe, expect, it } from "vite-plus/test";
4
5 import {
6 migratePersistedTerminalUiStateStoreState,
7 selectThreadTerminalUiState,
8 useTerminalUiStateStore,
9 } from "./terminalUiStateStore";
10 import { DEFAULT_THREAD_TERMINAL_ID } from "./types";
11
12 const THREAD_ID = ThreadId.make("thread-1");
13 const THREAD_REF = scopeThreadRef("environment-a" as never, THREAD_ID);
14 const OTHER_THREAD_REF = scopeThreadRef("environment-b" as never, THREAD_ID);
15 const layout = () =>
16 selectThreadTerminalUiState(
17 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
18 THREAD_REF,
19 );
20
21 describe("terminalUiStateStore actions", () => {
22 beforeEach(() => {
23 useTerminalUiStateStore.persist.clearStorage();
24 useTerminalUiStateStore.setState({
25 terminalUiStateByThreadKey: {},
26 serverObservationsByThreadKey: {},
27 suppressedTerminalIdsByThreadKey: {},
28 });
29 });
30
31 it("caps splits at four terminals per group", () => {
32 const store = useTerminalUiStateStore.getState();
33 store.splitTerminal(THREAD_REF, "terminal-2");
34 store.splitTerminal(THREAD_REF, "terminal-3");
35 store.splitTerminal(THREAD_REF, "terminal-4");
36 store.splitTerminal(THREAD_REF, "terminal-5");
37 store.splitTerminal(THREAD_REF, "terminal-6");
38
39 const terminalUiState = selectThreadTerminalUiState(
40 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
41 THREAD_REF,
42 );
43 expect(terminalUiState.terminalIds).toEqual([
44 "terminal-2",
45 "terminal-3",
46 "terminal-4",
47 "terminal-5",
48 ]);
49 expect(terminalUiState.terminalGroups).toEqual([
50 {
51 id: "group-terminal-2",
52 terminalIds: ["terminal-2", "terminal-3", "terminal-4", "terminal-5"],
53 },
54 ]);
55 });
56
57 it("keeps state isolated per environment when raw thread ids collide", () => {
58 const store = useTerminalUiStateStore.getState();
59 store.setTerminalOpen(THREAD_REF, true);
60 store.newTerminal(OTHER_THREAD_REF, "env-b-terminal");
61
62 expect(
63 selectThreadTerminalUiState(
64 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
65 THREAD_REF,
66 ).terminalOpen,
67 ).toBe(true);
68 expect(
69 selectThreadTerminalUiState(
70 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
71 OTHER_THREAD_REF,
72 ).terminalIds,
73 ).toEqual(["env-b-terminal"]);
74 });
75
76 it("drops persisted entries whose thread keys are not valid scoped keys", () => {
77 const migrated = migratePersistedTerminalUiStateStoreState(
78 {
79 terminalStateByThreadKey: {
80 [scopedThreadKey(THREAD_REF)]: {
81 terminalOpen: true,
82 terminalHeight: 320,
83 terminalIds: ["term-1"],
84 activeTerminalId: "term-1",
85 terminalGroups: [{ id: "group-term-1", terminalIds: ["term-1"] }],
86 activeTerminalGroupId: "group-term-1",
87 },
88 "legacy-thread-id": {
89 terminalOpen: true,
90 terminalHeight: 320,
91 terminalIds: ["term-1"],
92 activeTerminalId: "term-1",
93 terminalGroups: [{ id: "group-term-1", terminalIds: ["term-1"] }],
94 activeTerminalGroupId: "group-term-1",
95 },
96 },
97 },
98 2,
99 );
100
101 expect(migrated).toEqual({
102 terminalUiStateByThreadKey: {
103 [scopedThreadKey(THREAD_REF)]: {
104 terminalOpen: true,
105 terminalHeight: 320,
106 terminalIds: ["term-1"],
107 activeTerminalId: "term-1",
108 terminalGroups: [{ id: "group-term-1", terminalIds: ["term-1"] }],
109 activeTerminalGroupId: "group-term-1",
110 },
111 },
112 });
113 });
114
115 it("resets to default and clears persisted entry when closing the last terminal", () => {
116 const store = useTerminalUiStateStore.getState();
117 store.newTerminal(THREAD_REF, "terminal-only");
118 store.closeTerminal(THREAD_REF, "terminal-only");
119
120 expect(
121 useTerminalUiStateStore.getState().terminalUiStateByThreadKey[scopedThreadKey(THREAD_REF)],
122 ).toBeUndefined();
123 expect(
124 selectThreadTerminalUiState(
125 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
126 THREAD_REF,
127 ).terminalIds,
128 ).toEqual([]);
129 });
130
131 it("keeps a valid active terminal after closing an active split terminal", () => {
132 const store = useTerminalUiStateStore.getState();
133 store.splitTerminal(THREAD_REF, "terminal-2");
134 store.splitTerminal(THREAD_REF, "terminal-3");
135 store.closeTerminal(THREAD_REF, "terminal-3");
136
137 const terminalUiState = selectThreadTerminalUiState(
138 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
139 THREAD_REF,
140 );
141 expect(terminalUiState.activeTerminalId).toBe("terminal-2");
142 expect(terminalUiState.terminalIds).toEqual(["terminal-2"]);
143 expect(terminalUiState.terminalGroups).toEqual([
144 { id: "group-terminal-2", terminalIds: ["terminal-2"] },
145 ]);
146 });
147
148 it.each([
149 ["terminal-3", "terminal-3", DEFAULT_THREAD_TERMINAL_ID],
150 [DEFAULT_THREAD_TERMINAL_ID, DEFAULT_THREAD_TERMINAL_ID, "terminal-3"],
151 ["terminal-3", DEFAULT_THREAD_TERMINAL_ID, "terminal-3"],
152 ])("keeps the split's tab when %s is active and %s closes", (activeId, closedId, nextId) => {
153 const store = useTerminalUiStateStore.getState();
154 store.setTerminalOpen(THREAD_REF, true);
155 store.newTerminal(THREAD_REF, "terminal-2");
156 store.setActiveTerminal(THREAD_REF, DEFAULT_THREAD_TERMINAL_ID);
157 store.splitTerminal(THREAD_REF, "terminal-3");
158 store.setActiveTerminal(THREAD_REF, activeId);
159 store.closeTerminal(THREAD_REF, closedId);
160
161 const terminalUiState = selectThreadTerminalUiState(
162 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
163 THREAD_REF,
164 );
165 expect(terminalUiState.activeTerminalId).toBe(nextId);
166 expect(terminalUiState.activeTerminalGroupId).toBe(`group-${DEFAULT_THREAD_TERMINAL_ID}`);
167 });
168
169 it("does not import a closed panel terminal from stale metadata", () => {
170 const store = useTerminalUiStateStore.getState();
171 store.newTerminal(THREAD_REF, "term-2");
172 store.closeTerminal(THREAD_REF, "term-1");
173
174 store.reconcileTerminalIds(THREAD_REF, ["term-1", "term-2"]);
175
176 expect(
177 selectThreadTerminalUiState(
178 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
179 THREAD_REF,
180 ).terminalIds,
181 ).toEqual(["term-2"]);
182
183 store.newTerminal(THREAD_REF, "term-1");
184 expect(
185 selectThreadTerminalUiState(
186 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
187 THREAD_REF,
188 ).terminalIds,
189 ).toEqual(["term-2", "term-1"]);
190 });
191
192 it("drops terminals the server stops reporting but keeps ones it has not reported yet", () => {
193 const store = useTerminalUiStateStore.getState();
194 store.setTerminalOpen(THREAD_REF, true);
195 store.newTerminal(THREAD_REF, "term-2");
196 store.newTerminal(THREAD_REF, "term-3");
197 const terminalIds = () =>
198 selectThreadTerminalUiState(
199 useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
200 THREAD_REF,
201 ).terminalIds;
202
203 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID, "term-2"]);
204 expect(terminalIds()).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-2", "term-3"]);
205
206 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID]);
207 expect(terminalIds()).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-3"]);
208 });
209
210 it("preserves a vertical split while the terminals reattach to a restarted server", () => {
211 const store = useTerminalUiStateStore.getState();
212 const firstSnapshot = "manager-1";
213 const restartSnapshot = "manager-2";
214 store.setTerminalOpen(THREAD_REF, true);
215 store.splitTerminalVertical(THREAD_REF, "split");
216 const beforeRestart = layout();
217
218 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID, "split"], firstSnapshot);
219 store.reconcileTerminalIds(THREAD_REF, [], restartSnapshot);
220 expect(layout()).toEqual(beforeRestart);
221
222 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID], restartSnapshot);
223 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID, "split"], restartSnapshot);
224 expect(layout()).toEqual(beforeRestart);
225
226 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID], restartSnapshot);
227 expect(layout().terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
228 });
229
230 it("drops a background terminal that closed before the drawer reloaded", async () => {
231 const store = useTerminalUiStateStore.getState();
232 store.setTerminalOpen(THREAD_REF, true);
233 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID, "old"], "manager-1");
234 const { name, storage } = useTerminalUiStateStore.persist.getOptions();
235 if (!name || !storage) throw new Error("Terminal layout storage is unavailable");
236 const saved = await storage.getItem(name);
237 if (!saved) throw new Error("Terminal layout was not saved");
238 store.removeTerminalUiState(THREAD_REF);
239 await storage.setItem(name, saved);
240 await useTerminalUiStateStore.persist.rehydrate();
241
242 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID, "new"], "manager-1");
243
244 expect(layout().terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID, "new"]);
245 });
246
247 it.each([
248 ["unmounts right after the close", false],
249 ["sees the closing terminal once more before it unmounts", true],
250 ])("keeps a reopened terminal when the drawer %s", (_case, staleReconcile) => {
251 const store = useTerminalUiStateStore.getState();
252 store.setTerminalOpen(THREAD_REF, true);
253 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID], "manager-1");
254 store.closeTerminal(THREAD_REF, DEFAULT_THREAD_TERMINAL_ID);
255 if (staleReconcile) {
256 store.reconcileTerminalIds(THREAD_REF, [DEFAULT_THREAD_TERMINAL_ID], "manager-1");
257 }
258 // The drawer is gone now, so nothing reconciles the server dropping the terminal.
259 store.ensureTerminal(THREAD_REF, DEFAULT_THREAD_TERMINAL_ID, { open: true });
260 store.reconcileTerminalIds(THREAD_REF, [], "manager-1");
261
262 expect(layout().terminalOpen).toBe(true);
263 expect(layout().terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
264 });
265
266 it("keeps the surviving pane active when another client closes its split sibling", () => {
267 const store = useTerminalUiStateStore.getState();
268 store.newTerminal(THREAD_REF, "first");
269 store.newTerminal(THREAD_REF, "second");
270 store.splitTerminalVertical(THREAD_REF, "split");
271 store.reconcileTerminalIds(THREAD_REF, ["first", "second", "split"]);
272
273 store.reconcileTerminalIds(THREAD_REF, ["first", "second"]);
274
275 expect(layout().activeTerminalId).toBe("second");
276 expect(layout().activeTerminalGroupId).toBe("group-second");
277 });
278
279 it("preserves a pending local split when another client opens a tab", () => {
280 const store = useTerminalUiStateStore.getState();
281 store.reconcileTerminalIds(THREAD_REF, ["first"]);
282 store.splitTerminalVertical(THREAD_REF, "pending");
283
284 store.reconcileTerminalIds(THREAD_REF, ["first", "elsewhere"]);
285 store.reconcileTerminalIds(THREAD_REF, ["first", "elsewhere", "pending"]);
286
287 expect(layout().terminalGroups).toEqual([
288 { id: "group-first", terminalIds: ["first", "pending"], splitDirection: "vertical" },
289 { id: "group-elsewhere", terminalIds: ["elsewhere"] },
290 ]);
291 expect(layout().activeTerminalId).toBe("pending");
292 });
293 });