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