@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, 04:45 UTC

main
ts 257 lines 9.96 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { it } from "@effect/vitest";
4 import { type PreviewEvent, ThreadId } from "@t3tools/contracts";
5 import * as Effect from "effect/Effect";
6 import * as Layer from "effect/Layer";
7 import * as PubSub from "effect/PubSub";
8 import { expect } from "vite-plus/test";
9
10 import * as ServerConfig from "../config.ts";
11 import * as PreviewManager from "./Manager.ts";
12
13 const DRAIN_LIMIT = 100;
14
15 interface EventCollector {
16 readonly drain: Effect.Effect<ReadonlyArray<PreviewEvent>>;
17 }
18
19 /** The shared live layer retains state between tests; counts need unique thread ids. */
20 let nextThreadId = 0;
21 const freshThreadId = () => ThreadId.make(`thread-${++nextThreadId}`);
22
23 /** Subscribe synchronously before publishing so the forked consumer cannot miss events. */
24 const collectEvents = Effect.gen(function* () {
25 const manager = yield* PreviewManager.PreviewManager;
26 const subscription = yield* manager.subscribeEvents;
27 const collector: EventCollector = {
28 drain: PubSub.takeUpTo(subscription, DRAIN_LIMIT),
29 };
30 return collector;
31 }).pipe(Effect.withSpan("preview.test.collectEvents"));
32
33 const layer = PreviewManager.layer.pipe(
34 Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-preview-manager-" })),
35 Layer.provide(NodeCrypto.layer),
36 Layer.provide(NodeServices.layer),
37 );
38
39 it.layer(layer)("PreviewManager", (it) => {
40 it.effect("opens a session and emits opened with normalized URL", () =>
41 Effect.gen(function* () {
42 const threadId = freshThreadId();
43 const manager = yield* PreviewManager.PreviewManager;
44 const collector = yield* collectEvents;
45
46 const snapshot = yield* manager.open({ threadId, url: "localhost:5173" });
47 expect(snapshot.tabId.startsWith("tab_")).toBe(true);
48 expect(snapshot.navStatus._tag).toBe("Loading");
49 if (snapshot.navStatus._tag === "Loading") {
50 expect(snapshot.navStatus.url).toBe("http://localhost:5173/");
51 }
52
53 const events = yield* collector.drain;
54 expect(events).toHaveLength(1);
55 expect(events[0]?.type).toBe("opened");
56 if (events[0]?.type === "opened") {
57 expect(events[0].tabId).toBe(snapshot.tabId);
58 }
59 }),
60 );
61
62 it.effect("keeps the tab's profile across status reports", () =>
63 Effect.gen(function* () {
64 const threadId = freshThreadId();
65 const manager = yield* PreviewManager.PreviewManager;
66
67 const opened = yield* manager.open({ threadId, profileId: "work" });
68 expect(opened.profileId).toBe("work");
69
70 yield* manager.reportStatus({
71 threadId,
72 tabId: opened.tabId,
73 navStatus: { _tag: "Success", url: "http://localhost:5173/", title: "Dev" },
74 canGoBack: true,
75 canGoForward: false,
76 });
77 const listed = yield* manager.list({ threadId });
78 expect(listed.sessions.find((s) => s.tabId === opened.tabId)?.profileId).toBe("work");
79 }),
80 );
81
82 it.effect("opens a server tab with the requested zoom and appearance", () =>
83 Effect.gen(function* () {
84 const threadId = freshThreadId();
85 const manager = yield* PreviewManager.PreviewManager;
86 const rendering = { zoomFactor: 0.8, colorScheme: "dark" } as const;
87
88 const opened = yield* manager.open({ threadId, runtime: "server", ...rendering });
89
90 expect(opened).toMatchObject(rendering);
91 }),
92 );
93
94 it.effect("reissues presentation requests without replaying them on navigation", () =>
95 Effect.gen(function* () {
96 const threadId = freshThreadId();
97 const manager = yield* PreviewManager.PreviewManager;
98 const collector = yield* collectEvents;
99 const opened = yield* manager.open({ threadId, runtime: "server", reveal: false });
100 yield* manager.requestReveal({ threadId, tabId: opened.tabId, force: true });
101 const first = (yield* manager.list({ threadId })).sessions[0];
102 expect(first?.reveal).toBe(true);
103 expect(first?.revealRequest?.force).toBe(true);
104 yield* manager.reportStatus({
105 threadId,
106 tabId: opened.tabId,
107 serverControlled: true,
108 navStatus: { _tag: "Success", url: "http://localhost:5173/", title: "Dev" },
109 canGoBack: false,
110 canGoForward: false,
111 });
112 expect((yield* manager.list({ threadId })).sessions[0]?.revealRequest).toEqual(
113 first?.revealRequest,
114 );
115 yield* manager.requestReveal({ threadId, tabId: opened.tabId, force: false });
116 const second = (yield* manager.list({ threadId })).sessions[0];
117 expect(second?.revealRequest?.id).not.toBe(first?.revealRequest?.id);
118 expect(second?.revealRequest?.force).toBe(false);
119 const events = yield* collector.drain;
120 const last = events.at(-1);
121 expect(last?.type).toBe("navigated");
122 if (last?.type === "navigated")
123 expect(last.snapshot.revealRequest).toEqual(second?.revealRequest);
124 }),
125 );
126
127 it.effect("orders list snapshots and events with one monotonic revision", () =>
128 Effect.gen(function* () {
129 const threadId = freshThreadId();
130 const manager = yield* PreviewManager.PreviewManager;
131 const collector = yield* collectEvents;
132 const before = yield* manager.list({ threadId });
133
134 const opened = yield* manager.open({ threadId, url: "http://localhost:5173" });
135 yield* manager.reportStatus({
136 threadId,
137 tabId: opened.tabId,
138 navStatus: { _tag: "Success", url: "http://localhost:5173/ready", title: "Ready" },
139 canGoBack: true,
140 canGoForward: false,
141 });
142
143 const events = yield* collector.drain;
144 const listed = yield* manager.list({ threadId });
145 expect(events).toHaveLength(2);
146 expect(events[0]!.serverEpoch).toBe(listed.serverEpoch);
147 expect(events[1]!.serverEpoch).toBe(listed.serverEpoch);
148 expect(events[0]!.revision).toBeGreaterThan(before.revision);
149 expect(events[1]!.revision).toBeGreaterThan(events[0]!.revision);
150 expect(listed.revision).toBe(events[1]!.revision);
151 expect(listed.sessions).toHaveLength(1);
152 }),
153 );
154
155 it.effect("resizes a tab and preserves its viewport across navigation reports", () =>
156 Effect.gen(function* () {
157 const threadId = freshThreadId();
158 const manager = yield* PreviewManager.PreviewManager;
159 const collector = yield* collectEvents;
160 const opened = yield* manager.open({ threadId, url: "http://localhost:5173" });
161
162 const resized = yield* manager.resize({
163 threadId,
164 tabId: opened.tabId,
165 viewport: { _tag: "freeform", width: 1024, height: 768 },
166 });
167 expect(resized.viewport).toEqual({ _tag: "freeform", width: 1024, height: 768 });
168
169 yield* manager.reportStatus({
170 threadId,
171 tabId: opened.tabId,
172 navStatus: { _tag: "Success", url: "http://localhost:5173/resized", title: "Resized" },
173 canGoBack: true,
174 canGoForward: false,
175 });
176 const listed = yield* manager.list({ threadId });
177 expect(listed.sessions[0]?.viewport).toEqual(resized.viewport);
178
179 const events = yield* collector.drain;
180 expect(events.map((event) => event.type)).toEqual(["opened", "resized", "navigated"]);
181 }),
182 );
183
184 it.effect(
185 "rejects client status reports for server tabs without changing state or emitting events",
186 () =>
187 Effect.gen(function* () {
188 const threadId = freshThreadId();
189 const manager = yield* PreviewManager.PreviewManager;
190 const opened = yield* manager.open({ threadId, runtime: "server", reveal: false });
191 const collector = yield* collectEvents;
192 const before = yield* manager.list({ threadId });
193 const input = {
194 threadId,
195 tabId: opened.tabId,
196 navStatus: {
197 _tag: "Success" as const,
198 url: "http://localhost:5173/changed",
199 title: "Changed",
200 },
201 canGoBack: true,
202 canGoForward: true,
203 };
204 const rejected = yield* manager.reportStatus(input).pipe(Effect.flip);
205 expect(rejected._tag).toBe("PreviewControlRequiredError");
206 expect(yield* manager.list({ threadId })).toEqual(before);
207 expect(yield* collector.drain).toEqual([]);
208
209 yield* manager.reportStatus({ ...input, serverControlled: true });
210 expect((yield* manager.list({ threadId })).sessions[0]).toMatchObject({
211 navStatus: input.navStatus,
212 canGoBack: true,
213 canGoForward: true,
214 });
215 const events = yield* collector.drain;
216 expect(events).toHaveLength(1);
217 expect(events[0]).toMatchObject({
218 type: "navigated",
219 snapshot: { navStatus: input.navStatus },
220 });
221 }),
222 );
223
224 it.effect("gives every tab in a batch close its own monotonic revision", () =>
225 Effect.gen(function* () {
226 const threadId = freshThreadId();
227 const manager = yield* PreviewManager.PreviewManager;
228 yield* manager.open({ threadId, url: "http://localhost:5173" });
229 yield* manager.open({ threadId, url: "http://localhost:3000" });
230 const collector = yield* collectEvents;
231
232 yield* manager.close({ threadId });
233
234 const events = yield* collector.drain;
235 const listed = yield* manager.list({ threadId });
236 expect(events).toHaveLength(2);
237 expect(events.every((event) => event.type === "closed")).toBe(true);
238 expect(events[1]!.revision).toBeGreaterThan(events[0]!.revision);
239 expect(listed.revision).toBe(events[1]!.revision);
240 expect(listed.sessions).toHaveLength(0);
241 }),
242 );
243
244 it.effect("close with explicit tabId removes only that tab", () =>
245 Effect.gen(function* () {
246 const threadId = freshThreadId();
247 const manager = yield* PreviewManager.PreviewManager;
248 const a = yield* manager.open({ threadId, url: "http://localhost:5173" });
249 const b = yield* manager.open({ threadId, url: "http://localhost:3000" });
250
251 yield* manager.close({ threadId, tabId: a.tabId });
252
253 const list = yield* manager.list({ threadId });
254 expect(list.sessions.map((s) => s.tabId)).toEqual([b.tabId]);
255 }),
256 );
257 });