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

main
ts 301 lines 11.7 KB
Raw
1 import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment";
2 import { type DesktopBridge, EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";
3 import { describe, expect, it, vi } from "vite-plus/test";
4
5 import {
6 DraftId,
7 hydrateImagesFromPersisted,
8 useComposerDraftStore,
9 } from "../../composerDraftStore";
10 import * as imageCompression from "../../lib/imageCompression";
11 import {
12 questionAttachmentDraftId,
13 trackOpenQuestionAttachmentDraft,
14 } from "../../questionAttachments";
15 import {
16 beginSnapShotAnimationWhenReady,
17 deliverSnapShot,
18 dismissFailedSnapShot,
19 resolveExistingSnapShotTarget,
20 resolveSnapShotAttachmentTarget,
21 resolveSnapShotDeliveryTarget,
22 } from "./SnapShotCoordinator";
23 import {
24 beginSnapShotAnimation,
25 dismissAllSnapShotAnimations,
26 getPendingSnapShotAnimations,
27 scheduleSnapShotAnimationDestination,
28 } from "../../lib/snapShotAnimation";
29
30 vi.mock(import("../../hooks/useSettings"), { spy: true });
31 vi.mock(import("../../hooks/useHandleNewThread"), { spy: true });
32 vi.mock(import("../../lib/snapShotSound"), { spy: true });
33 vi.mock(import("../../lib/imageCompression"), { spy: true });
34
35 const storage = vi.hoisted(() => {
36 const values = new Map<string, string>();
37 const storage = {
38 getItem: (key: string) => values.get(key) ?? null,
39 setItem: vi.fn((key: string, value: string) => {
40 values.set(key, value);
41 }),
42 removeItem: (key: string) => {
43 values.delete(key);
44 },
45 clear: () => values.clear(),
46 };
47 vi.stubGlobal("localStorage", storage);
48 return storage;
49 });
50
51 const environmentId = EnvironmentId.make("snap-shot-environment");
52 const projectRef = scopeProjectRef(environmentId, ProjectId.make("snap-shot-project"));
53
54 // Tests stub globals and spy on module exports freely; disposing restores all of them.
55 function setup(): Disposable {
56 storage.clear();
57 vi.stubGlobal("localStorage", storage);
58 useComposerDraftStore.setState({
59 draftsByThreadKey: {},
60 draftThreadsByThreadKey: {},
61 logicalProjectDraftThreadKeyByLogicalProjectKey: {},
62 stickyModelSelectionByProvider: {},
63 stickyActiveProvider: null,
64 });
65 return {
66 [Symbol.dispose]() {
67 dismissAllSnapShotAnimations();
68 vi.unstubAllGlobals();
69 vi.restoreAllMocks();
70 },
71 };
72 }
73
74 describe("window capture failures", () => {
75 it("does not resurrect a failed capture when its draft becomes ready later", async () => {
76 using _env = setup();
77 const target = DraftId.make("snap-shot-draft");
78 let resolveTarget: ((target: DraftId) => void) | undefined;
79 const targetReady = new Promise<DraftId>((resolve) => {
80 resolveTarget = resolve;
81 });
82 const pendingStarts = new Set<string>();
83 const soundedIds = new Set(["older", "newer"]);
84 const olderStart = beginSnapShotAnimationWhenReady("older", targetReady, pendingStarts);
85 await beginSnapShotAnimationWhenReady("newer", Promise.resolve(target), pendingStarts);
86
87 dismissFailedSnapShot("older", soundedIds, pendingStarts);
88 resolveTarget?.(target);
89 await olderStart;
90
91 expect(getPendingSnapShotAnimations().map(({ id }) => id)).toEqual(["newer"]);
92 expect(soundedIds).toEqual(new Set(["newer"]));
93 expect(pendingStarts.size).toBe(0);
94 });
95 });
96
97 describe("window capture target resolution", () => {
98 it("follows a draft to its promoted server thread", () => {
99 using _env = setup();
100 const draftId = DraftId.make("snap-shot-draft");
101 const promotedRef = scopeThreadRef(environmentId, ThreadId.make("snap-shot-promoted-thread"));
102 const store = useComposerDraftStore.getState();
103 store.setProjectDraftThreadId(projectRef, draftId, {
104 threadId: ThreadId.make("snap-shot-draft-thread"),
105 });
106 store.markDraftThreadPromoting(draftId, promotedRef);
107
108 expect(resolveExistingSnapShotTarget(draftId, null)).toEqual(promotedRef);
109 });
110 });
111
112 describe("open question delivery", () => {
113 const threadRef = scopeThreadRef(environmentId, ThreadId.make("question-thread"));
114 const first = questionAttachmentDraftId(environmentId, threadRef.threadId, "request-1", "q1");
115 const second = questionAttachmentDraftId(environmentId, threadRef.threadId, "request-1", "q2");
116 const request = { draftId: first, requestKeys: [first, second] };
117 const capture = {
118 id: "12345678-1234-1234-1234-123456789abc",
119 name: "window.png",
120 mimeType: "image/png" as const,
121 sizeBytes: 3,
122 dataUrl: "data:image/png;base64,AQID",
123 source: {
124 kind: "snap-shot" as const,
125 capturedAt: "2026-09-01T00:00:00.000Z",
126 appName: "Editor",
127 windowTitle: "main.ts",
128 },
129 };
130 const makeBridge = (readSnapShot: () => Promise<typeof capture> = async () => capture) => {
131 const acknowledgeSnapShot = vi.fn(async () => undefined);
132 const bridge = { readSnapShot, acknowledgeSnapShot } as unknown as DesktopBridge;
133 return { bridge, acknowledgeSnapShot };
134 };
135
136 it("attaches a capture to the open question draft and leaves the thread draft alone", async () => {
137 using _env = setup();
138 const pins = new Map();
139 const untrack = trackOpenQuestionAttachmentDraft(threadRef, request);
140 try {
141 const { bridge, acknowledgeSnapShot } = makeBridge();
142 await deliverSnapShot(bridge, capture, () =>
143 resolveSnapShotAttachmentTarget(pins, capture.id, threadRef),
144 );
145 const store = useComposerDraftStore.getState();
146 expect(store.getComposerDraft(first)?.images.map(({ id }) => id)).toEqual([capture.id]);
147 expect(store.getComposerDraft(threadRef)?.images ?? []).toHaveLength(0);
148 expect(acknowledgeSnapShot).toHaveBeenCalledExactlyOnceWith(capture.id);
149 const repeat = hydrateImagesFromPersisted([{ ...capture, id: "repeat" }]);
150 expect(store.addImages(first, repeat)).toEqual([]);
151 expect(store.getComposerDraft(first)?.images.map(({ id }) => id)).toEqual([capture.id]);
152 } finally {
153 untrack();
154 }
155 });
156
157 it("falls back to the thread when a newer question replaces the pinned one during compression", async () => {
158 using _env = setup();
159 const pins = new Map();
160 const untrackFirst = trackOpenQuestionAttachmentDraft(threadRef, request);
161 let untrackSecond = () => {};
162 const compression = vi
163 .spyOn(imageCompression, "compressImageToByteLimit")
164 .mockImplementationOnce(async (file) => {
165 untrackSecond = trackOpenQuestionAttachmentDraft(threadRef, {
166 ...request,
167 draftId: second,
168 });
169 untrackFirst();
170 return { ok: true, file, recompressed: false };
171 });
172 try {
173 const { bridge, acknowledgeSnapShot } = makeBridge();
174 const resolveTarget = () => resolveSnapShotAttachmentTarget(pins, capture.id, threadRef);
175 expect(resolveTarget()).toBe(first);
176 await deliverSnapShot(bridge, capture, resolveTarget);
177 const store = useComposerDraftStore.getState();
178 expect(store.getComposerDraft(first)?.images ?? []).toHaveLength(0);
179 expect(store.getComposerDraft(second)?.images ?? []).toHaveLength(0);
180 expect(store.getComposerDraft(threadRef)?.images.map(({ id }) => id)).toEqual([capture.id]);
181 expect(acknowledgeSnapShot).toHaveBeenCalledExactlyOnceWith(capture.id);
182 } finally {
183 compression.mockRestore();
184 untrackFirst();
185 untrackSecond();
186 }
187 });
188
189 it("keeps a capture pinned before any question off a question that opens during the read", async () => {
190 using _env = setup();
191 const pins = new Map();
192 const resolveTarget = () => resolveSnapShotAttachmentTarget(pins, capture.id, threadRef);
193 // The drain pins a capture it never saw requested before reading it.
194 expect(resolveTarget()).toEqual(threadRef);
195 let untrack = () => {};
196 const { bridge, acknowledgeSnapShot } = makeBridge(async () => {
197 untrack = trackOpenQuestionAttachmentDraft(threadRef, request);
198 return capture;
199 });
200 try {
201 await deliverSnapShot(bridge, capture, resolveTarget);
202 const store = useComposerDraftStore.getState();
203 expect(store.getComposerDraft(first)?.images ?? []).toHaveLength(0);
204 expect(store.getComposerDraft(threadRef)?.images.map(({ id }) => id)).toEqual([capture.id]);
205 expect(acknowledgeSnapShot).toHaveBeenCalledExactlyOnceWith(capture.id);
206 } finally {
207 untrack();
208 }
209 });
210 });
211
212 describe("durable snapshot delivery", () => {
213 it.each([false, true])(
214 "retains a capture on quota failure and retries without duplicates (staged: %s)",
215 async (staged) => {
216 using _env = setup();
217 const target = scopeThreadRef(environmentId, ThreadId.make("quota-thread"));
218 const capture = {
219 id: "12345678-1234-1234-1234-123456789abc",
220 name: "window.png",
221 mimeType: "image/png" as const,
222 sizeBytes: 3,
223 dataUrl: "data:image/png;base64,AQID",
224 source: {
225 kind: "snap-shot" as const,
226 capturedAt: "2026-09-01T00:00:00.000Z",
227 appName: "Editor",
228 windowTitle: "main.ts",
229 },
230 };
231 const acknowledgeSnapShot = vi.fn(async () => undefined);
232 const bridge = {
233 readSnapShot: async () => capture,
234 acknowledgeSnapShot,
235 } as unknown as DesktopBridge;
236 const write = storage.setItem.getMockImplementation()!;
237 storage.setItem.mockImplementation(() => {
238 throw new Error("QuotaExceededError");
239 });
240 try {
241 if (staged) {
242 const store = useComposerDraftStore.getState();
243 store.addImage(target, {
244 type: "image",
245 ...capture,
246 previewUrl: capture.dataUrl,
247 file: new File([new Uint8Array([1, 2, 3])], capture.name, { type: capture.mimeType }),
248 });
249 void store.syncPersistedAttachments(target, [capture]);
250 }
251 await expect(deliverSnapShot(bridge, capture, () => target)).rejects.toThrow(
252 "could not be saved",
253 );
254 expect(acknowledgeSnapShot).not.toHaveBeenCalled();
255 expect(
256 useComposerDraftStore.getState().getComposerDraft(target)?.nonPersistedImageIds,
257 ).toContain(capture.id);
258 storage.setItem.mockImplementation(write);
259 await deliverSnapShot(bridge, capture, () => target);
260 expect(acknowledgeSnapShot).toHaveBeenCalledExactlyOnceWith(capture.id);
261 expect(useComposerDraftStore.getState().getComposerDraft(target)?.images).toHaveLength(1);
262 expect(
263 useComposerDraftStore.getState().getComposerDraft(target)?.persistedAttachments,
264 ).toHaveLength(1);
265 } finally {
266 storage.setItem.mockImplementation(write);
267 }
268 },
269 );
270 });
271
272 describe("snapshot destination ownership", () => {
273 it.each(["unmount", "blur", "disabled animations"])(
274 "keeps the original environment and thread after %s",
275 async (reason) => {
276 using _env = setup();
277 const original = scopeThreadRef(environmentId, ThreadId.make("original"));
278 const next = scopeThreadRef(EnvironmentId.make("another-environment"), ThreadId.make("next"));
279 const targets = new Map<string, Promise<typeof original | null>>();
280 let current = original;
281 const resolveTarget = async () => current;
282 const requested = resolveSnapShotDeliveryTarget(targets, "capture", resolveTarget);
283 if (reason !== "disabled animations") {
284 beginSnapShotAnimation("capture", original);
285 if (reason === "unmount") {
286 const unmount = scheduleSnapShotAnimationDestination("capture", () => undefined);
287 unmount();
288 } else dismissAllSnapShotAnimations();
289 }
290 current = next;
291 await requested;
292 expect(getPendingSnapShotAnimations()).toHaveLength(0);
293 expect(await resolveSnapShotDeliveryTarget(targets, "capture", resolveTarget)).toEqual(
294 original,
295 );
296 expect(await resolveSnapShotDeliveryTarget(targets, "later-capture", resolveTarget)).toEqual(
297 next,
298 );
299 },
300 );
301 });