@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 484 lines 19.8 KB
Raw
1 // @effect-diagnostics nodeBuiltinImport:off - Hands a real file on disk to a real desktop browser.
2 import * as NodeEvents from "node:events";
3 import * as NodeFS from "node:fs";
4 import * as NodeHttp from "node:http";
5 import type * as NodeNet from "node:net";
6 import * as NodeOS from "node:os";
7 import * as NodePath from "node:path";
8
9 import { INCOGNITO_BROWSER_PROFILE_ID } from "@t3tools/contracts";
10 import * as HostProcess from "@t3tools/shared/HostProcess";
11 import { it as effectIt } from "@effect/vitest";
12 import * as Effect from "effect/Effect";
13 import { chromium, type Browser, type BrowserContext, type BrowserType } from "playwright-core";
14 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
15
16 import { presentAsChrome, ServerBrowserContexts } from "./ServerBrowserContexts.ts";
17
18 const launches = vi.hoisted(() => ({
19 launch: vi.fn<BrowserType["launch"]>(),
20 persistent: vi.fn<BrowserType["launchPersistentContext"]>(),
21 mkdir: vi.fn().mockResolvedValue(undefined),
22 rm: vi.fn().mockResolvedValue(undefined),
23 }));
24 const launchChromium = chromium.launch.bind(chromium);
25 const launchPersistentChromium = chromium.launchPersistentContext.bind(chromium);
26 vi.spyOn(chromium, "launch").mockImplementation(launches.launch);
27 vi.spyOn(chromium, "launchPersistentContext").mockImplementation(launches.persistent);
28 vi.mock("node:fs/promises", () => ({ mkdir: launches.mkdir, rm: launches.rm }));
29
30 const makeContext = () => {
31 const events = new NodeEvents.EventEmitter();
32 let closed = false;
33 return {
34 on: vi.fn((event: string, listener: () => void) => events.on(event, listener)),
35 pages: vi.fn(() => []),
36 newPage: vi.fn(async () => ({ once: vi.fn() })),
37 isClosed: () => closed,
38 close: vi.fn(async () => {
39 if (!closed) {
40 closed = true;
41 events.emit("close");
42 }
43 }),
44 };
45 };
46
47 const makeBrowser = () => {
48 const events = new NodeEvents.EventEmitter();
49 const contexts: ReturnType<typeof makeContext>[] = [];
50 return {
51 created: contexts,
52 contexts: () => contexts.filter((context) => !context.isClosed()),
53 on: vi.fn((event: string, listener: () => void) => events.on(event, listener)),
54 newContext: vi.fn(async () => {
55 const context = makeContext();
56 contexts.push(context);
57 return context as unknown as BrowserContext;
58 }),
59 close: vi.fn(async () => {
60 for (const context of contexts) await context.close();
61 events.emit("disconnected");
62 }),
63 };
64 };
65
66 const options = () => ({
67 profilesDir: "/test/profiles",
68 executable: vi.fn(async () => "/test/chromium"),
69 env: {},
70 chrome: { version: "157.0.8103.78", platform: "linux" as NodeJS.Platform },
71 });
72
73 const withLauncher = () => {
74 const release = vi.fn(async () => {});
75 return {
76 release,
77 configuration: {
78 ...options(),
79 launcher: vi.fn(async (executable: string) => ({ path: `${executable}-launcher`, release })),
80 },
81 };
82 };
83
84 beforeEach(() => {
85 launches.launch.mockReset();
86 launches.persistent.mockReset();
87 launches.mkdir.mockClear();
88 launches.rm.mockClear();
89 });
90
91 describe("ServerBrowserContexts", () => {
92 it("closes the shared browser only after it holds no context for the idle period", async () => {
93 vi.useFakeTimers();
94 try {
95 const first = makeBrowser();
96 const second = makeBrowser();
97 launches.launch
98 .mockResolvedValueOnce(first as unknown as Browser)
99 .mockResolvedValueOnce(second as unknown as Browser);
100 const pool = new ServerBrowserContexts({ ...options(), idleBrowserMs: 10 });
101 const agent = await pool.contextFor("default", "agent");
102 await pool.scratchPage();
103 await agent.close();
104 await vi.advanceTimersByTimeAsync(10);
105 expect(first.close).not.toHaveBeenCalled();
106 await first.created[1]!.close();
107 await vi.advanceTimersByTimeAsync(9);
108 const next = await pool.contextFor("default", "next");
109 await vi.advanceTimersByTimeAsync(10);
110 expect(first.close).not.toHaveBeenCalled();
111 await next.close();
112 await vi.advanceTimersByTimeAsync(10);
113 expect(first.close).toHaveBeenCalledOnce();
114 await pool.contextFor("default", "later");
115 expect(launches.launch).toHaveBeenCalledTimes(2);
116 expect(second.newContext).toHaveBeenCalledOnce();
117 await pool.close();
118 } finally {
119 vi.useRealTimers();
120 }
121 });
122
123 it("closes a scratch context when creating its page fails", async () => {
124 const browser = makeBrowser();
125 launches.launch.mockResolvedValue(browser as unknown as Browser);
126 const pool = new ServerBrowserContexts(options());
127 const peer = await pool.contextFor("default", "peer");
128 const context = await browser.newContext();
129 const failure = new Error("newPage failed");
130 browser.created[1]!.newPage.mockRejectedValueOnce(failure);
131 browser.newContext.mockResolvedValueOnce(context);
132 try {
133 await expect(pool.scratchPage()).rejects.toBe(failure);
134 expect(context.close).toHaveBeenCalledOnce();
135 expect(browser.contexts()).toEqual([peer]);
136 expect(peer.close).not.toHaveBeenCalled();
137 expect(browser.close).not.toHaveBeenCalled();
138 } finally {
139 await pool.close();
140 }
141 });
142
143 it("lazily shares one browser across concurrent isolated sessions and reuses each context", async () => {
144 const browser = makeBrowser();
145 const launch = Promise.withResolvers<Browser>();
146 const started = Promise.withResolvers<void>();
147 launches.launch.mockImplementation(() => {
148 started.resolve();
149 return launch.promise;
150 });
151 const { configuration, release } = withLauncher();
152 const pool = new ServerBrowserContexts(configuration);
153 expect(configuration.executable).not.toHaveBeenCalled();
154 const first = pool.contextFor("default", "agent-a");
155 const again = pool.contextFor("default", "agent-a");
156 const second = pool.contextFor("default", "agent-b");
157 const incognito = pool.contextFor(INCOGNITO_BROWSER_PROFILE_ID);
158 await started.promise;
159 // Playwright may retry the same path until the launch settles.
160 expect(release).not.toHaveBeenCalled();
161 launch.resolve(browser as unknown as Browser);
162 const [a, reused, b, privateContext] = await Promise.all([first, again, second, incognito]);
163 expect(release).toHaveBeenCalledTimes(1);
164 expect(a).toBe(reused);
165 expect(new Set([a, b, privateContext]).size).toBe(3);
166 expect(launches.launch).toHaveBeenCalledExactlyOnceWith(
167 expect.objectContaining({ executablePath: "/test/chromium-launcher" }),
168 );
169 expect(launches.persistent).not.toHaveBeenCalled();
170 expect(browser.newContext).toHaveBeenCalledWith({
171 viewport: { width: 1280, height: 800 },
172 deviceScaleFactor: 2,
173 });
174 await pool.close();
175 expect(browser.close).toHaveBeenCalledTimes(1);
176 for (const context of browser.created) expect(context.close).toHaveBeenCalled();
177 });
178
179 it("keeps human profiles persistent without sharing their storage with agents", async () => {
180 const human = makeContext();
181 const browser = makeBrowser();
182 launches.persistent.mockResolvedValue(human as unknown as BrowserContext);
183 launches.launch.mockResolvedValue(browser as unknown as Browser);
184 const { configuration, release } = withLauncher();
185 const pool = new ServerBrowserContexts(configuration);
186 const persistent = await pool.contextFor("work/team");
187 expect(await pool.contextFor("work/team")).toBe(persistent);
188 expect(await pool.contextFor("work/team", "agent")).not.toBe(persistent);
189 expect(launches.persistent).toHaveBeenCalledExactlyOnceWith(
190 "/test/profiles/work%2Fteam",
191 expect.objectContaining({ chromiumSandbox: true, executablePath: "/test/chromium-launcher" }),
192 );
193 expect(release).toHaveBeenCalledTimes(2);
194 expect(launches.mkdir).toHaveBeenCalledWith("/test/profiles/work%2Fteam", { recursive: true });
195 await pool.close();
196 expect(human.close).toHaveBeenCalledTimes(1);
197 });
198
199 it("diagnoses a launcher failure against the real executable", async () => {
200 const diagnosed = new Error("diagnosed");
201 const diagnose = vi.fn(async () => diagnosed);
202 const pool = new ServerBrowserContexts({
203 ...options(),
204 diagnose,
205 launcher: vi.fn(async () => {
206 throw new Error("EACCES");
207 }),
208 });
209 await expect(pool.contextFor("default", "agent")).rejects.toBe(diagnosed);
210 expect(diagnose).toHaveBeenCalledExactlyOnceWith("/test/chromium", expect.any(Error));
211 expect(launches.launch).not.toHaveBeenCalled();
212 });
213
214 it("creates no launcher for a profile whose storage cannot be created", async () => {
215 launches.mkdir.mockRejectedValueOnce(new Error("EACCES"));
216 const { configuration } = withLauncher();
217 const pool = new ServerBrowserContexts(configuration);
218 await expect(pool.contextFor("work/team")).rejects.toThrow("EACCES");
219 expect(configuration.launcher).not.toHaveBeenCalled();
220 });
221
222 it("clears a profile by closing its open context before deleting its storage", async () => {
223 const human = makeContext();
224 const browser = makeBrowser();
225 launches.persistent.mockResolvedValue(human as unknown as BrowserContext);
226 launches.launch.mockResolvedValue(browser as unknown as Browser);
227 const onContextClose = vi.fn();
228 const pool = new ServerBrowserContexts({ ...options(), onContextClose });
229 const persistent = await pool.contextFor("work/team");
230 const agent = await pool.contextFor("work/team", "agent");
231 launches.rm.mockImplementationOnce(async () => {
232 expect(human.close).toHaveBeenCalledTimes(1);
233 });
234 await pool.clearProfile("work/team");
235 expect(onContextClose).toHaveBeenCalledExactlyOnceWith(persistent);
236 expect(launches.rm).toHaveBeenCalledExactlyOnceWith("/test/profiles/work%2Fteam", {
237 recursive: true,
238 force: true,
239 });
240 expect(await pool.contextFor("work/team", "agent")).toBe(agent);
241 expect(browser.created[0]?.close).not.toHaveBeenCalled();
242 launches.persistent.mockResolvedValue(makeContext() as unknown as BrowserContext);
243 expect(await pool.contextFor("work/team")).not.toBe(persistent);
244 await pool.clearProfile("never-opened");
245 expect(launches.rm).toHaveBeenLastCalledWith("/test/profiles/never-opened", {
246 recursive: true,
247 force: true,
248 });
249 await pool.close();
250 });
251
252 it("waits for the context to close when the same profile is cleared concurrently", async () => {
253 const human = makeContext();
254 const closed = Promise.withResolvers<void>();
255 human.close.mockImplementation(async () => closed.promise);
256 launches.persistent.mockResolvedValue(human as unknown as BrowserContext);
257 const pool = new ServerBrowserContexts(options());
258 await pool.contextFor("work/team");
259
260 const first = pool.clearProfile("work/team");
261 const second = pool.clearProfile("work/team");
262 const deletionsBeforeClose = launches.rm.mock.calls.length;
263 closed.resolve();
264 await Promise.all([first, second]);
265
266 expect(deletionsBeforeClose).toBe(0);
267 expect(human.close).toHaveBeenCalledTimes(1);
268 expect(launches.rm).toHaveBeenCalledExactlyOnceWith("/test/profiles/work%2Fteam", {
269 recursive: true,
270 force: true,
271 });
272 await pool.close();
273 });
274
275 it("opens a profile requested during its clear only after the storage is deleted", async () => {
276 launches.persistent.mockImplementation(async () => makeContext() as unknown as BrowserContext);
277 const configuration = options();
278 const pool = new ServerBrowserContexts(configuration);
279 await pool.contextFor("work/team");
280 const removing = Promise.withResolvers<void>();
281 const removed = Promise.withResolvers<void>();
282 let deleted = false;
283 launches.rm.mockImplementationOnce(async () => {
284 removing.resolve();
285 await removed.promise;
286 deleted = true;
287 });
288 const launchedAfterDelete: Array<boolean> = [];
289 configuration.executable.mockImplementation(async () => {
290 launchedAfterDelete.push(deleted);
291 return "/test/chromium";
292 });
293 const clearing = pool.clearProfile("work/team");
294 const reopening = pool.contextFor("work/team");
295 await removing.promise;
296 removed.resolve();
297 await Promise.all([clearing, reopening]);
298 expect(launchedAfterDelete).toEqual([true]);
299 await pool.close();
300 });
301
302 it.each([undefined, "default"])(
303 "never retries a failed %s launch with the sandbox disabled",
304 async (profile) => {
305 const launch = profile ? launches.persistent : launches.launch;
306 launch.mockRejectedValue(new Error("sandbox unavailable"));
307 const pool = new ServerBrowserContexts(options());
308 await expect(pool.contextFor(profile ?? INCOGNITO_BROWSER_PROFILE_ID)).rejects.toThrow(
309 "sandbox unavailable",
310 );
311 expect(launch).toHaveBeenCalledTimes(1);
312 expect(
313 profile ? launches.persistent.mock.calls[0]?.[1] : launches.launch.mock.calls[0]?.[0],
314 ).toMatchObject({ chromiumSandbox: true });
315 await pool.close();
316 },
317 );
318
319 it("allows only an explicit sandbox opt-out", async () => {
320 const browser = makeBrowser();
321 launches.launch.mockResolvedValue(browser as unknown as Browser);
322 const pool = new ServerBrowserContexts({
323 ...options(),
324 env: { T3CODE_SERVER_BROWSER_SANDBOX: "0" },
325 });
326 await pool.contextFor(INCOGNITO_BROWSER_PROFILE_ID);
327 expect(launches.launch).toHaveBeenCalledWith(
328 expect.objectContaining({ chromiumSandbox: false }),
329 );
330 await pool.close();
331 });
332
333 it("retries a failed startup on a later request with sandboxing still enabled", async () => {
334 const browser = makeBrowser();
335 launches.launch
336 .mockRejectedValueOnce(new Error("executable unavailable"))
337 .mockResolvedValue(browser as unknown as Browser);
338 const pool = new ServerBrowserContexts(options());
339 await expect(pool.contextFor("default", "agent")).rejects.toThrow("executable unavailable");
340 await pool.contextFor("default", "agent");
341 expect(launches.launch).toHaveBeenCalledTimes(2);
342 expect(launches.launch).toHaveBeenLastCalledWith(
343 expect.objectContaining({ chromiumSandbox: true }),
344 );
345 await pool.close();
346 });
347
348 it("cleans up a browser whose launch finishes during shutdown and rejects future work", async () => {
349 const browser = makeBrowser();
350 const launch = Promise.withResolvers<Browser>();
351 launches.launch.mockReturnValue(launch.promise);
352 const pool = new ServerBrowserContexts(options());
353 const opening = expect(pool.contextFor("default", "agent")).rejects.toThrow("closed");
354 const closing = pool.close();
355 launch.resolve(browser as unknown as Browser);
356 await Promise.all([opening, closing]);
357 await expect(pool.contextFor("default", "agent")).rejects.toThrow("closed");
358 await pool.close();
359 expect(browser.close).toHaveBeenCalledTimes(1);
360 expect(browser.created[0]?.close).toHaveBeenCalled();
361 });
362
363 it("uploads a file over 50 MB to a desktop tab, which shares the server's filesystem", async () => {
364 const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-desktop-upload-"));
365 const userDataDir = NodePath.join(directory, "profile");
366 const pool = new ServerBrowserContexts(options());
367 try {
368 // Chromium can write DevToolsActivePort after Playwright's launch resolves, so the port is chosen here.
369 const reserved = NodeHttp.createServer();
370 await new Promise<void>((resolve) => reserved.listen(0, "127.0.0.1", resolve));
371 const { port } = reserved.address() as NodeNet.AddressInfo;
372 await new Promise((resolve) => reserved.close(resolve));
373 const desktop = await launchPersistentChromium(userDataDir, {
374 headless: true,
375 args: [`--remote-debugging-port=${port}`],
376 });
377 try {
378 const { browser, page } = await pool.connectDesktopPage(`http://127.0.0.1:${port}`);
379 try {
380 const file = NodePath.join(directory, "large.bin");
381 NodeFS.writeFileSync(file, "");
382 NodeFS.truncateSync(file, 51 * 1024 * 1024);
383 await page.setContent(`<input type="file">`);
384 await page.locator("input").setInputFiles(file);
385 expect(
386 await page.$eval("input", (input) =>
387 Array.from(
388 (input as unknown as { files: ArrayLike<{ name: string; size: number }> }).files,
389 ({ name, size }) => ({ name, size }),
390 ),
391 ),
392 ).toEqual([{ name: "large.bin", size: 51 * 1024 * 1024 }]);
393 } finally {
394 await browser.close();
395 }
396 } finally {
397 await pool.close();
398 await desktop.close();
399 }
400 } finally {
401 NodeFS.rmSync(directory, { recursive: true, force: true });
402 }
403 });
404
405 const sendsOneChromeIdentity = async (host: {
406 readonly platform: NodeJS.Platform;
407 readonly arch: string;
408 }) => {
409 // The pool's own launch options, on the browser Playwright installs for tests.
410 launches.launch.mockImplementation((launch = {}) => {
411 const { executablePath: _installed, ...bundled } = launch;
412 return launchChromium(bundled);
413 });
414 const server = NodeHttp.createServer((request, response) => {
415 const send = (type: string, body: string) =>
416 response.writeHead(200, { "content-type": type }).end(body);
417 if (request.url === "/worker.js") {
418 return send(
419 "text/javascript",
420 `addEventListener("activate", (event) => event.waitUntil(clients.claim()));
421 addEventListener("fetch", (event) => event.respondWith(fetch(event.request)));`,
422 );
423 }
424 if (request.url === "/identity") {
425 return send(
426 "application/json",
427 JSON.stringify({
428 userAgent: request.headers["user-agent"],
429 brands: request.headers["sec-ch-ua"],
430 }),
431 );
432 }
433 return send("text/html", "<!doctype html>");
434 });
435 await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
436 try {
437 // What this browser sends on this host without any override, as the oracle.
438 const probe = await launchChromium();
439 const version = probe.version();
440 const major = version.split(".")[0];
441 const headless = await (await probe.newPage()).evaluate(() => navigator.userAgent);
442 await probe.close();
443 const pool = new ServerBrowserContexts({
444 ...options(),
445 env: { ...process.env, T3CODE_SERVER_BROWSER_SANDBOX: "0" },
446 chrome: { version, platform: host.platform },
447 });
448 try {
449 const context = await pool.contextFor(INCOGNITO_BROWSER_PROFILE_ID);
450 const page = await context.newPage();
451 await presentAsChrome(await context.newCDPSession(page), host);
452 await page.goto(`http://127.0.0.1:${(server.address() as NodeNet.AddressInfo).port}/`);
453 const [fromPage, throughWorker] = (await page.evaluate(`(async () => {
454 const identity = async () => (await fetch("/identity")).json();
455 const fromPage = await identity();
456 const controlled = new Promise((resolve) =>
457 navigator.serviceWorker.addEventListener("controllerchange", resolve, { once: true }),
458 );
459 await navigator.serviceWorker.register("/worker.js");
460 await controlled;
461 return [fromPage, await identity()];
462 })()`)) as ReadonlyArray<{ readonly userAgent: string; readonly brands: string }>;
463 expect(headless).toContain(`HeadlessChrome/${version} `);
464 expect(fromPage?.userAgent).toBe(
465 headless.replace(`HeadlessChrome/${version}`, `Chrome/${major}.0.0.0`),
466 );
467 expect(fromPage?.brands).toContain('"Google Chrome"');
468 expect(throughWorker?.userAgent).toBe(fromPage?.userAgent);
469 } finally {
470 await pool.close();
471 }
472 } finally {
473 server.closeAllConnections();
474 await new Promise<void>((resolve) => server.close(() => resolve()));
475 }
476 };
477
478 effectIt.live("sends one Chrome identity from a page and from its service worker", () =>
479 Effect.gen(function* () {
480 const host = { platform: yield* HostProcess.Platform, arch: yield* HostProcess.Architecture };
481 yield* Effect.promise(() => sendsOneChromeIdentity(host));
482 }),
483 );
484 });