The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }); |