Open History to see the last commit
1import * as NodeHttpPlatform from "@effect/platform-node/NodeHttpPlatform";
2import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
3import * as NodeServices from "@effect/platform-node/NodeServices";
4import { expect, it } from "@effect/vitest";
5import {
6 AuthOrchestrationOperateScope,
7 AuthOrchestrationReadScope,
8 AuthPreviewOperateScope,
9 AuthSessionId,
10 PREVIEW_STREAM_HOST_SETUP_CLOSE_CODE,
11 PreviewStreamHostSetup,
12 type AuthEnvironmentScope,
13} from "@t3tools/contracts";
14import * as Context from "effect/Context";
15import * as Effect from "effect/Effect";
16import * as FileSystem from "effect/FileSystem";
17import * as Layer from "effect/Layer";
18import * as Option from "effect/Option";
19import * as Queue from "effect/Queue";
20import * as Schema from "effect/Schema";
21import { HttpRouter, HttpServer } from "effect/http";
22
23import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
24import * as PreviewBrowserHost from "./PreviewBrowserHost.ts";
25import * as ServerBrowser from "./ServerBrowser.ts";
26import { routeLayer } from "./ServerBrowserStream.ts";
27
28const platformLayer = NodeHttpPlatform.layer.pipe(Layer.provideMerge(NodeServices.layer));
29
30const makeAuth = (
31 scopes: ReadonlyArray<AuthEnvironmentScope>,
32 error?: EnvironmentAuth.ServerAuthCredentialError,
33) => {
34 const requests: string[] = [];
35 const layer = Layer.mock(EnvironmentAuth.EnvironmentAuth, {
36 authenticateWebSocketUpgrade: (request) => {
37 requests.push(request.url);
38 return error
39 ? Effect.fail(error)
40 : Effect.succeed({
41 sessionId: AuthSessionId.make("stream-test"),
42 subject: "stream-test",
43 method: "bearer-access-token",
44 scopes,
45 });
46 },
47 });
48 return { layer, requests };
49};
50
51const mutations = [
52 { type: "resize", width: 390, height: 844 },
53 { type: "mouse", action: "down", x: 10, y: 10, button: "left", buttons: 1 },
54 { type: "key", action: "down", key: "Enter" },
55 { type: "text", text: "reader must not type" },
56 { type: "wheel", deltaY: 100 },
57 { type: "navigate", url: "https://example.com" },
58 { type: "history", delta: -1 },
59 { type: "reload" },
60 { type: "probe", x: 10, y: 10 },
61 { type: "takeControl" },
62 { type: "releaseControl" },
63 { type: "dialog", accept: true },
64 { type: "viewport", setting: { _tag: "fill" } },
65];
66
67it.effect.each([
68 { hasOperateScope: false, interactive: true },
69 { hasOperateScope: true, interactive: true },
70 { hasOperateScope: true, interactive: false },
71])("streams frames and acks while gating page mutations (%s)", ({ hasOperateScope, interactive }) =>
72 Effect.gen(function* () {
73 const canOperate = hasOperateScope && interactive;
74 const scopes = hasOperateScope
75 ? [AuthOrchestrationReadScope, AuthPreviewOperateScope]
76 : [AuthOrchestrationReadScope];
77 const auth = makeAuth(scopes);
78 const inputs: unknown[] = [];
79 const attachments: Parameters<ServerBrowser.ServerBrowser["Service"]["attachViewer"]>[0][] = [];
80 const acked = Promise.withResolvers<void>();
81 const frame = new Uint8Array([255, 216, 255, 217]);
82 const output = yield* Queue.make<ServerBrowser.ServerBrowserViewerOutput>();
83 yield* Queue.offer(output, { _tag: "viewport", width: 1280, height: 800 });
84 yield* Queue.offer(output, {
85 _tag: "frame",
86 data: frame,
87 ack: Effect.sync(() => acked.resolve()),
88 });
89 const browser = ServerBrowser.ServerBrowser.of({
90 clearProfile: () => Effect.void,
91 close: () => Effect.void,
92 profileReporter: Effect.succeed(() => Effect.void),
93 openDownload: () => Effect.succeedNone,
94 answerFileChooser: () => Effect.succeed(false),
95 attachViewer: (input) =>
96 Effect.sync(() => {
97 attachments.push(input);
98 return {
99 output,
100 input: (message) => Effect.sync(() => void inputs.push(message)),
101 };
102 }),
103 });
104 const services = yield* Layer.build(
105 HttpRouter.serve(
106 routeLayer.pipe(
107 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
108 Layer.provide(platformLayer),
109 ),
110 { disableListenLog: true },
111 ).pipe(Layer.provideMerge(NodeHttpServer.layerTest), Layer.provide(auth.layer)),
112 );
113 const server = Context.get(services, HttpServer.HttpServer);
114 const origin = HttpServer.formatAddress(server.address).replace(/^http/, "ws");
115 const resource = `/api/preview-stream/ws?threadId=thread&tabId=tab&wsTicket=one-use-ticket${interactive ? "" : "&interactive=false"}`;
116 const received = Promise.withResolvers<void>();
117 const socket = yield* Effect.acquireRelease(
118 Effect.sync(() => new WebSocket(`${origin}${resource}`)),
119 (socket) => Effect.sync(() => socket.close()),
120 );
121 socket.binaryType = "arraybuffer";
122 const viewports: unknown[] = [];
123 const frames: Uint8Array[] = [];
124 socket.addEventListener("error", () => received.reject(new Error("stream failed")));
125 socket.addEventListener("message", (event) => {
126 if (typeof event.data === "string") {
127 viewports.push(JSON.parse(event.data));
128 return;
129 }
130 frames.push(new Uint8Array(event.data as ArrayBuffer));
131 for (const message of mutations) socket.send(JSON.stringify(message));
132 socket.send("malformed input");
133 socket.send(JSON.stringify({ type: "ack" }));
134 received.resolve();
135 });
136 yield* Effect.promise(() => received.promise);
137 // The socket ack follows every mutation, providing a barrier without sleeps.
138 yield* Effect.promise(() => acked.promise);
139 expect(frames).toEqual([frame]);
140 expect(viewports).toEqual([{ type: "viewport", width: 1280, height: 800 }]);
141 expect(inputs).toEqual(canOperate ? [...mutations, null] : []);
142 expect(attachments).toEqual([
143 {
144 threadId: "thread",
145 tabId: "tab",
146 maxWidth: 1280,
147 maxHeight: 800,
148 quality: 70,
149 canOperate,
150 },
151 ]);
152 expect(auth.requests).toEqual([resource]);
153 }).pipe(Effect.scoped),
154);
155
156it.effect("sends replies ahead of stale frames and only the newest frame after an ack", () =>
157 Effect.gen(function* () {
158 const output = yield* Queue.make<ServerBrowser.ServerBrowserViewerOutput>();
159 const released: number[] = [];
160 const frame = (id: number): ServerBrowser.ServerBrowserViewerOutput => ({
161 _tag: "frame",
162 data: new Uint8Array([id]),
163 ack: Effect.sync(() => void released.push(id)),
164 });
165 const browser = ServerBrowser.ServerBrowser.of({
166 clearProfile: () => Effect.void,
167 close: () => Effect.void,
168 profileReporter: Effect.succeed(() => Effect.void),
169 openDownload: () => Effect.succeedNone,
170 answerFileChooser: () => Effect.succeed(false),
171 attachViewer: () => Effect.succeed({ output, input: () => Effect.void }),
172 });
173 const services = yield* Layer.build(
174 HttpRouter.serve(
175 routeLayer.pipe(
176 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
177 Layer.provide(platformLayer),
178 ),
179 { disableListenLog: true },
180 ).pipe(
181 Layer.provideMerge(NodeHttpServer.layerTest),
182 Layer.provide(makeAuth([AuthOrchestrationReadScope]).layer),
183 ),
184 );
185 const server = Context.get(services, HttpServer.HttpServer);
186 const origin = HttpServer.formatAddress(server.address).replace(/^http/, "ws");
187 const received: Array<number | string> = [];
188 let next = Promise.withResolvers<void>();
189 const socket = yield* Effect.acquireRelease(
190 Effect.sync(
191 () =>
192 new WebSocket(
193 `${origin}/api/preview-stream/ws?threadId=thread&tabId=tab&wsTicket=one-use-ticket`,
194 ),
195 ),
196 (socket) => Effect.sync(() => socket.close()),
197 );
198 socket.binaryType = "arraybuffer";
199 socket.addEventListener("message", (event) => {
200 received.push(
201 typeof event.data === "string"
202 ? JSON.parse(event.data).type
203 : new Uint8Array(event.data as ArrayBuffer)[0]!,
204 );
205 next.resolve();
206 });
207
208 yield* Queue.offer(output, frame(1));
209 yield* Effect.promise(() => next.promise);
210 next = Promise.withResolvers();
211 yield* Queue.offerAll(output, [
212 frame(2),
213 frame(3),
214 frame(4),
215 { _tag: "probe", x: 0, y: 0, editable: false },
216 ]);
217 yield* Effect.promise(() => next.promise);
218 expect(received).toEqual([1, "probe"]);
219 expect(released).toEqual([2, 3]);
220
221 next = Promise.withResolvers();
222 socket.send(JSON.stringify({ type: "ack" }));
223 yield* Effect.promise(() => next.promise);
224 expect(received).toEqual([1, "probe", 4]);
225 expect(released).toEqual([2, 3, 1]);
226 }).pipe(Effect.scoped),
227);
228
229it.effect.each([
230 { scopes: [], error: undefined, status: 403 },
231 { scopes: [AuthOrchestrationOperateScope], error: undefined, status: 403 },
232 { scopes: [], error: new EnvironmentAuth.ServerAuthMissingCredentialError({}), status: 401 },
233])("rejects unauthorized stream connections before attaching a viewer (%s)", (testCase) =>
234 Effect.gen(function* () {
235 const auth = makeAuth(testCase.scopes, testCase.error);
236 let attachments = 0;
237 const browser = ServerBrowser.ServerBrowser.of({
238 clearProfile: () => Effect.void,
239 close: () => Effect.void,
240 profileReporter: Effect.succeed(() => Effect.void),
241 openDownload: () => Effect.succeedNone,
242 answerFileChooser: () => Effect.succeed(false),
243 attachViewer: () => {
244 attachments++;
245 return Effect.die("unauthorized viewer must not attach");
246 },
247 });
248 const handler = yield* Effect.acquireRelease(
249 Effect.sync(() =>
250 HttpRouter.toWebHandler(
251 routeLayer.pipe(
252 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
253 Layer.provide(platformLayer),
254 Layer.provideMerge(auth.layer),
255 ),
256 { disableLogger: true },
257 ),
258 ),
259 ({ dispose }) => Effect.promise(dispose),
260 );
261 const response = yield* Effect.promise(() =>
262 handler.handler(
263 new Request("http://t3.test/api/preview-stream/ws?threadId=thread&tabId=tab", {
264 headers: { upgrade: "websocket" },
265 }),
266 ),
267 );
268 expect(response.status).toBe(testCase.status);
269 expect(attachments).toBe(0);
270 }).pipe(Effect.scoped),
271);
272
273it.effect("serves a tab's download only to an authorized session", () =>
274 Effect.gen(function* () {
275 const fs = yield* FileSystem.FileSystem;
276 const path = `${yield* fs.makeTempDirectoryScoped({ prefix: "t3-download-" })}/file`;
277 yield* fs.writeFileString(path, "report contents");
278 const requests: Array<unknown> = [];
279 const browser = ServerBrowser.ServerBrowser.of({
280 clearProfile: () => Effect.void,
281 close: () => Effect.void,
282 profileReporter: Effect.succeed(() => Effect.void),
283 openDownload: (input) =>
284 Effect.sync(() => {
285 requests.push(input);
286 return input.downloadId === "download-1"
287 ? Option.some({ path, fileName: "Q3 report.csv" })
288 : Option.none();
289 }),
290 answerFileChooser: () => Effect.succeed(false),
291 attachViewer: () => Effect.die("unused"),
292 });
293 const serve = (scopes: ReadonlyArray<AuthEnvironmentScope>, url: string) =>
294 Effect.gen(function* () {
295 const handler = yield* Effect.acquireRelease(
296 Effect.sync(() =>
297 HttpRouter.toWebHandler(
298 routeLayer.pipe(
299 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
300 Layer.provide(platformLayer),
301 Layer.provideMerge(makeAuth(scopes, undefined).layer),
302 ),
303 { disableLogger: true },
304 ),
305 ),
306 ({ dispose }) => Effect.promise(dispose),
307 );
308 return yield* Effect.promise(() => handler.handler(new Request(url)));
309 });
310 const base = "http://t3.test/api/preview-stream/download?threadId=thread&tabId=tab";
311 const denied = yield* serve([], `${base}&id=download-1`);
312 expect(denied.status).toBe(403);
313 expect(requests).toEqual([]);
314 const response = yield* serve([AuthOrchestrationReadScope], `${base}&id=download-1`);
315 expect(response.status).toBe(200);
316 expect(response.headers.get("content-disposition")).toBe(
317 'attachment; filename="Q3 report.csv"',
318 );
319 expect(yield* Effect.promise(() => response.text())).toBe("report contents");
320 const missing = yield* serve([AuthOrchestrationReadScope], `${base}&id=other`);
321 expect(missing.status).toBe(404);
322 }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
323);
324
325it.effect("passes uploaded files to the page's open picker and needs operate scope", () =>
326 Effect.gen(function* () {
327 const answers: Array<{ chooserId: string; files: Array<{ name: string; text: string }> }> = [];
328 const browser = ServerBrowser.ServerBrowser.of({
329 clearProfile: () => Effect.void,
330 close: () => Effect.void,
331 profileReporter: Effect.succeed(() => Effect.void),
332 openDownload: () => Effect.succeedNone,
333 answerFileChooser: (input) =>
334 Effect.sync(() => {
335 answers.push({
336 chooserId: input.chooserId,
337 files: input.files.map((file) => ({ name: file.name, text: file.buffer.toString() })),
338 });
339 return input.chooserId === "chooser-1";
340 }),
341 attachViewer: () => Effect.die("unused"),
342 });
343 const upload = (scopes: ReadonlyArray<AuthEnvironmentScope>, chooser: string) =>
344 Effect.gen(function* () {
345 const handler = yield* Effect.acquireRelease(
346 Effect.sync(() =>
347 HttpRouter.toWebHandler(
348 routeLayer.pipe(
349 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
350 Layer.provide(platformLayer),
351 Layer.provideMerge(makeAuth(scopes, undefined).layer),
352 ),
353 { disableLogger: true },
354 ),
355 ),
356 ({ dispose }) => Effect.promise(dispose),
357 );
358 const body = new FormData();
359 body.append("file", new File(["hello"], "notes.txt", { type: "text/plain" }));
360 return yield* Effect.promise(() =>
361 handler.handler(
362 new Request(
363 `http://t3.test/api/preview-stream/upload?threadId=thread&tabId=tab&chooser=${chooser}`,
364 { method: "POST", body },
365 ),
366 ),
367 );
368 });
369 expect((yield* upload([AuthOrchestrationReadScope], "chooser-1")).status).toBe(403);
370 expect(answers).toEqual([]);
371 expect((yield* upload([AuthOrchestrationOperateScope], "chooser-1")).status).toBe(403);
372 expect((yield* upload([AuthPreviewOperateScope], "chooser-1")).status).toBe(204);
373 expect(answers).toEqual([
374 { chooserId: "chooser-1", files: [{ name: "notes.txt", text: "hello" }] },
375 ]);
376 expect((yield* upload([AuthPreviewOperateScope], "stale")).status).toBe(409);
377 }).pipe(Effect.scoped),
378);
379
380const decodeHostSetup = Schema.decodeUnknownEffect(Schema.fromJsonString(PreviewStreamHostSetup));
381
382it.effect.each([
383 {
384 error: new PreviewBrowserHost.PreviewBrowserSandboxError({
385 setupCommand: "sudo t3 browser setup",
386 }),
387 need: "sandbox",
388 },
389 {
390 error: new PreviewBrowserHost.PreviewBrowserLibrariesError({
391 setupCommand: "sudo t3 browser setup",
392 libraries: ["libnss3.so"],
393 }),
394 need: "libraries",
395 },
396])("tells viewers the command that sets up the host ($need)", ({ error, need }) =>
397 Effect.gen(function* () {
398 const browser = ServerBrowser.ServerBrowser.of({
399 clearProfile: () => Effect.void,
400 close: () => Effect.void,
401 profileReporter: Effect.succeed(() => Effect.void),
402 openDownload: () => Effect.succeedNone,
403 answerFileChooser: () => Effect.succeed(false),
404 attachViewer: () => Effect.fail(new ServerBrowser.ServerBrowserLaunchError({ cause: error })),
405 });
406 const services = yield* Layer.build(
407 HttpRouter.serve(
408 routeLayer.pipe(
409 Layer.provide(Layer.succeed(ServerBrowser.ServerBrowser, browser)),
410 Layer.provide(platformLayer),
411 ),
412 { disableListenLog: true },
413 ).pipe(
414 Layer.provideMerge(NodeHttpServer.layerTest),
415 Layer.provide(makeAuth([AuthOrchestrationReadScope]).layer),
416 ),
417 );
418 const server = Context.get(services, HttpServer.HttpServer);
419 const origin = HttpServer.formatAddress(server.address).replace(/^http/, "ws");
420 const closed = Promise.withResolvers<{ code: number; reason: string }>();
421 yield* Effect.acquireRelease(
422 Effect.sync(() => {
423 const socket = new WebSocket(
424 `${origin}/api/preview-stream/ws?threadId=thread&tabId=tab&wsTicket=one-use-ticket`,
425 );
426 socket.addEventListener("close", (event) =>
427 closed.resolve({ code: event.code, reason: event.reason }),
428 );
429 return socket;
430 }),
431 (socket) => Effect.sync(() => socket.close()),
432 );
433 const { code, reason } = yield* Effect.promise(() => closed.promise);
434 expect(code).toBe(PREVIEW_STREAM_HOST_SETUP_CLOSE_CODE);
435 expect(yield* decodeHostSetup(reason)).toEqual({
436 need,
437 command: "sudo t3 browser setup",
438 });
439 }).pipe(Effect.scoped),
440);