import * as NodeEvents from "node:events";
import * as NodeVM from "node:vm";
// @effect-diagnostics-next-line nodeBuiltinImport:off - Playwright download mocks perform real file operations outside the Effect runtime.
import * as NodeFSP from "node:fs/promises";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { it } from "@effect/vitest";
import {
type BrowserRecordingFrameRate,
EnvironmentId,
PreviewTabId,
ProviderInstanceId,
ThreadId,
type PreviewAutomationSnapshot,
type PreviewAutomationStatus,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Scope from "effect/Scope";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as PubSub from "effect/PubSub";
import * as Queue from "effect/Queue";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import type { BrowserContext, Page } from "playwright-core";
import { beforeEach, expect, vi } from "vite-plus/test";
import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as Broker from "../mcp/PreviewAutomationBroker.ts";
import * as DesktopChannel from "./DesktopBrowserChannel.ts";
import * as Manager from "./Manager.ts";
import * as PreviewAgentActivity from "./PreviewAgentActivity.ts";
import * as ServerBrowser from "./ServerBrowser.ts";
import * as PreviewBrowser from "./PreviewBrowser.ts";
vi.mock("./ServerBrowserContexts.ts", () => ({
presentAsChrome: async () => {},
ServerBrowserContexts: class {
private readonly onClose: ((context: BrowserContext) => void) | undefined;
constructor(options: { onContextClose?: (context: BrowserContext) => void }) {
this.onClose = options.onContextClose;
}
async contextFor(profileId: string, isolationKey?: string) {
contextRequests.push({ profileId, isolated: isolationKey !== undefined });
if (contextFailure) throw contextFailure;
await contextGate?.promise;
const context = makeContext(this.onClose);
const setupFailure = pageSetupFailure;
if (setupFailure) {
context.newCDPSession = async () => {
throw setupFailure;
};
}
contexts.push(context);
return context as unknown as BrowserContext;
}
async scratchPage() {
return makeEncoderPage() as unknown as Page;
}
async connectDesktopPage(endpoint: string) {
const context = makeContext(undefined, desktopPageUrl);
context.page.viewportSize.mockReturnValue(null);
desktopConnections.push({ endpoint, context });
return { browser: { close: async () => {} }, page: context.page as unknown as Page };
}
async close() {
for (const context of contexts) await context.close();
}
},
}));
function makeFrame() {
const frame = {
copy: "",
detached: false,
isDetached: () => frame.detached,
recording: Promise.withResolvers<void>(),
};
return frame;
}
const PNG_HEADER = (() => {
const header = Buffer.alloc(24);
header.write("IHDR", 12);
header.writeUInt32BE(1280, 16);
header.writeUInt32BE(800, 20);
return header.toString("base64");
})();
function makeSession(
frame: ReturnType<typeof makeFrame> | undefined,
viewport: { width: number; height: number },
) {
const events = new NodeEvents.EventEmitter();
return {
on: vi.fn((name: string, callback: (...args: unknown[]) => void) => events.on(name, callback)),
emit: (name: string, ...args: unknown[]) => events.emit(name, ...args),
emitAsync: (name: string, ...args: unknown[]) =>
Promise.all(events.listeners(name).map((listener) => listener(...args))),
detach: vi.fn(async () => {}),
send: vi.fn(async (method: string, input?: unknown): Promise<Record<string, unknown>> => {
if (method === "Page.getNavigationHistory") return { currentIndex: 0, entries: [{}] };
if (method === "Page.getLayoutMetrics") return { cssVisualViewport: { pageX: 0, pageY: 0 } };
if (method === "Page.captureScreenshot") {
// A snapshot sizes its screenshot from the PNG header; viewers get JPEG frames as-is.
return { data: (input as { format: string }).format === "png" ? PNG_HEADER : "ZnJhbWU=" };
}
// Snapshots shrink their screenshot in the page; the header stands in for the result.
if (method === "Runtime.callFunctionOn") return { result: { value: PNG_HEADER } };
if (method === "Page.getFrameTree") return { frameTree: { frame: { id: "main" } } };
if (method === "Page.createIsolatedWorld") {
return {
executionContextId:
(input as { worldName?: string }).worldName === "t3-preview-viewport"
? 9
: (input as { worldName?: string }).worldName === "t3-preview"
? 1
: 7,
};
}
if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 1) {
return { result: { value: [] } };
}
if (method === "Page.addScriptToEvaluateOnNewDocument") frame?.recording.resolve();
if (method === "Input.dispatchKeyEvent" && (input as { commands?: unknown }).commands) {
if (focusedFrame) focusedFrame.copy = keyCopy || focusedFrame.copy;
else pageCopy = keyCopy || pageCopy;
}
if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 7) {
const value = frame ? frame.copy : pageCopy;
if (frame) frame.copy = "";
else pageCopy = "";
return { result: { value } };
}
if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 9)
return desktopSizeAnswer?.() ?? { result: { value: { ...viewport } } };
return { result: { value: "evaluated" } };
}),
};
}
function fileChooserElement(accept: string) {
return {
getAttribute: async () => accept,
evaluate: (probe: (element: { ownerDocument: unknown }) => boolean) =>
Promise.resolve(
probe({
ownerDocument: (globalThis as typeof globalThis & { document?: unknown }).document,
}),
),
};
}
function makeContext(onClose?: (context: BrowserContext) => void, initialUrl = "about:blank") {
const events = new NodeEvents.EventEmitter();
const nativeFileChooser = vi.fn();
const setChooserFiles = vi.fn(async (_files: unknown) => {});
const sessions: ReturnType<typeof makeSession>[] = [];
let url = initialUrl;
let viewport: ReturnType<Page["viewportSize"]> = { width: 1280, height: 800 };
const cssViewport = { width: 1920, height: 1080 };
let closed = false;
let contextClosed = false;
const page = {
on: (name: string, callback: (...args: unknown[]) => void) => events.on(name, callback),
once: (name: string, callback: (...args: unknown[]) => void) => events.once(name, callback),
off: (name: string, callback: (...args: unknown[]) => void) => events.off(name, callback),
emit: (name: string, ...args: unknown[]) => events.emit(name, ...args),
nativeFileChooser,
setChooserFiles,
openFileChooser: () => {
if (
!events.emit("filechooser", {
isMultiple: () => false,
element: () => fileChooserElement(".csv"),
setFiles: setChooserFiles,
})
) {
nativeFileChooser();
}
},
emitAsync: (name: string, ...args: unknown[]) =>
Promise.all(events.listeners(name).map((listener) => listener(...args))),
setDefaultTimeout: vi.fn(),
setDefaultNavigationTimeout: vi.fn(),
context: () => context,
mainFrame: () => page,
frames: () => [page],
url: () => url,
title: vi.fn(async () => "test page"),
viewportSize: vi.fn(() => viewport),
setViewportSize: vi.fn(async (size: typeof viewport) => {
viewport = size;
}),
goto: vi.fn(async (next: string) => {
url = next;
events.emit("load");
const pending = initialNavigation;
initialNavigation = null;
await pending?.();
}),
goBack: vi.fn(async () => {}),
goForward: vi.fn(async () => {}),
reload: vi.fn(async () => {}),
emulateMedia: vi.fn(async () => {}),
waitForLoadState: vi.fn(async () => {}),
evaluate: vi.fn(async () => ({
url,
title: "test page",
loading: false,
visibleText: "delete",
interactiveElements: [],
})),
ariaSnapshot: vi.fn(async () => '- button "delete" [ref=e1]'),
locator: vi.fn(() => {
throw new Error("Unexpected locator action");
}),
isClosed: () => closed,
close: vi.fn(async () => {
if (!closed) {
closed = true;
events.emit("close");
}
}),
};
const context = {
page,
sessions,
cssViewport,
newPage: async () => page as unknown as Page,
grantPermissions: vi.fn(async () => {}),
newCDPSession: async (target: unknown) => {
const session = makeSession(
target === page ? undefined : (target as ReturnType<typeof makeFrame>),
cssViewport,
);
sessions.push(session);
return session;
},
close: vi.fn(async () => {
if (contextClosed) return;
contextClosed = true;
await page.close();
onClose?.(context as unknown as BrowserContext);
}),
};
return context;
}
// Runs the real encoder script against fake canvas and MediaRecorder globals.
function makeEncoderPage() {
const canvas = {
width: 0,
height: 0,
getContext: () => ({ drawImage() {}, fillRect() {} }),
captureStream: (frameRate?: number) => ({ frameRate, getTracks: () => [] }),
};
class FakeMediaRecorder {
static isTypeSupported = (type: string) => type === "video/webm";
onstart: (() => void) | null = null;
constructor(stream: { frameRate?: number }, options: { videoBitsPerSecond: number }) {
encoderStreams.push({
frameRate: stream.frameRate,
bitsPerSecond: options.videoBitsPerSecond,
});
}
start() {
this.onstart?.();
}
}
const sandbox: Record<string, unknown> = {
document: { createElement: () => canvas },
Path2D: function Path2D() {},
MediaRecorder: FakeMediaRecorder,
createImageBitmap: async () => ({ width: 1280, height: 800, close() {} }),
atob,
Blob,
performance,
};
sandbox.window = sandbox;
const context = NodeVM.createContext(sandbox);
return {
...makeContext().page,
evaluate: vi.fn(async (script: string | ((arg: unknown) => unknown), arg?: unknown) =>
typeof script === "string"
? NodeVM.runInContext(script, context)
: NodeVM.runInContext(`(${script.toString()})`, context)(arg),
),
};
}
const contexts: ReturnType<typeof makeContext>[] = [];
const encoderStreams: Array<{ frameRate: number | undefined; bitsPerSecond: number }> = [];
const contextRequests: Array<{ profileId: string; isolated: boolean }> = [];
let contextGate: PromiseWithResolvers<void> | null = null;
let pageCopy = "";
let keyCopy = "";
let focusedFrame: ReturnType<typeof makeFrame> | null = null;
let contextFailure: Error | null = null;
let pageSetupFailure: Error | null = null;
let initialNavigation: (() => Promise<void>) | null = null;
let desktopRendersNext = false;
let desktopPageUrl = "about:blank";
/** Replaces the answer to the desktop page's size reads. */
let desktopSizeAnswer: (() => Promise<Record<string, unknown>>) | null = null;
const desktopDetaches = new NodeEvents.EventEmitter();
let desktopDetachReady = Promise.withResolvers<void>();
let desktopReleased = Promise.withResolvers<void>();
const desktopTabs = new Set<string>();
const desktopRenders = (tabId: string) => {
if (desktopRendersNext) {
desktopRendersNext = false;
desktopTabs.add(tabId);
}
return desktopTabs.has(tabId);
};
const shownDesktopTabs = new Set<string>();
const releasedDesktopTabs: Array<string> = [];
const desktopTurns = new NodeEvents.EventEmitter();
const desktopConnections: Array<{ endpoint: string; context: ReturnType<typeof makeContext> }> = [];
const testThread = {
threadId: ThreadId.make("browser-test-thread"),
providerSessionId: "agent-a",
providerInstanceId: ProviderInstanceId.make("codex"),
};
const scope = {
environmentId: EnvironmentId.make("browser-test-environment"),
thread: testThread,
client: undefined,
requestNamespace: "browser-test",
capabilities: new Set(["preview"] as const),
issuedAt: 1,
};
const asSession = (providerSessionId: string) => ({
...scope,
thread: { ...testThread, providerSessionId },
});
const dependencies = Layer.mergeAll(
Broker.layer,
Manager.layer,
Layer.succeed(ServerEnvironment.ServerEnvironment, {
getEnvironmentId: Effect.succeed(scope.environmentId),
getDescriptor: Effect.die("unused descriptor"),
}),
Layer.succeed(PreviewBrowser.PreviewBrowser, {
executable: Effect.die("mock Chromium does not need an executable"),
installed: Effect.die("mock Chromium does not need an executable"),
}),
Layer.succeed(DesktopChannel.DesktopBrowserChannel, {
available: true,
awaitAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
detached: Stream.callback<{ threadId: string; tabId: string }>((queue) =>
Effect.acquireRelease(
Effect.sync(() => {
const onDetach = (key: { threadId: string; tabId: string }) =>
Queue.offerUnsafe(queue, key);
desktopDetaches.on("detach", onDetach);
desktopDetachReady.resolve();
return onDetach;
}),
(onDetach) => Effect.sync(() => desktopDetaches.off("detach", onDetach)),
),
),
attached: Stream.callback<{ threadId: string; tabId: string }>((queue) =>
Effect.acquireRelease(
Effect.sync(() => {
const onAttach = (key: { threadId: string; tabId: string }) =>
Queue.offerUnsafe(queue, key);
desktopDetaches.on("attach", onAttach);
return onAttach;
}),
(onAttach) => Effect.sync(() => desktopDetaches.off("attach", onAttach)),
),
),
isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
isShown: (key) => shownDesktopTabs.has(key.tabId),
endpoint: (key) =>
Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () =>
Effect.sync(() => {
releasedDesktopTabs.push(key.tabId);
desktopDetaches.emit("release", key.tabId);
desktopReleased.resolve();
}),
),
pointer: () => Effect.void,
turn: (threadId, active) => Effect.sync(() => desktopTurns.emit("turn", threadId, active)),
}),
PreviewAgentActivity.layer,
).pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "t3-server-browser-" })),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
const layer = ServerBrowser.layer.pipe(Layer.provideMerge(dependencies));
const ready = Effect.gen(function* () {
const browser = yield* ServerBrowser.ServerBrowser;
const broker = yield* Broker.PreviewAutomationBroker;
yield* Effect.yieldNow;
const opened = yield* broker.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: { reuseExistingTab: false, show: false },
});
const tabId = PreviewTabId.make(opened.tabId!);
return { browser, broker, tabId };
});
const viewerInput = (tabId: string, canOperate: boolean) => ({
threadId: scope.thread.threadId,
tabId,
canOperate,
maxWidth: 1280,
maxHeight: 800,
quality: 70,
});
/** Fills a viewer's output with frames; resolves once every one of them is acknowledged. */
const stallViewer = (viewer: ServerBrowser.ServerBrowserViewer) => {
const output = viewer.output as unknown as Queue.Queue<ServerBrowser.ServerBrowserViewerOutput>;
const acked = Promise.withResolvers<void>();
let unacked = 0;
const ack = Effect.sync(() => {
if (--unacked === 0) acked.resolve();
});
while (Queue.offerUnsafe(output, { _tag: "frame", data: Buffer.alloc(0), ack })) unacked++;
return Effect.promise(() => acked.promise);
};
const viewportSizes = (items: ReadonlyArray<ServerBrowser.ServerBrowserViewerOutput>) =>
items.flatMap((item) => (item._tag === "viewport" ? [`${item.width}x${item.height}`] : []));
const openDesktopViewer = Effect.gen(function* () {
const browser = yield* ServerBrowser.ServerBrowser;
const manager = yield* Manager.PreviewManager;
desktopRendersNext = true;
const { tabId } = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
const context = desktopConnections[0]!.context;
const cdp = context.sessions[0]!;
const resize = (width: number, height: number) => {
Object.assign(context.cssViewport, { width, height });
return Effect.promise(() => cdp.emitAsync("Page.frameResized"));
};
return { tabId, viewer, context, cdp, resize };
});
beforeEach(() => {
contexts.length = 0;
encoderStreams.length = 0;
contextRequests.length = 0;
contextGate = null;
contextFailure = null;
pageSetupFailure = null;
initialNavigation = null;
pageCopy = "";
keyCopy = "";
focusedFrame = null;
desktopTabs.clear();
shownDesktopTabs.clear();
desktopRendersNext = false;
desktopPageUrl = "about:blank";
desktopSizeAnswer = null;
desktopDetachReady = Promise.withResolvers<void>();
desktopReleased = Promise.withResolvers<void>();
releasedDesktopTabs.length = 0;
desktopConnections.length = 0;
});
it.live("tells the desktop once per thread when its agent turns start and end", () =>
Effect.gen(function* () {
yield* ServerBrowser.ServerBrowser;
const activity = yield* PreviewAgentActivity.PreviewAgentActivity;
const threadId = scope.thread.threadId;
const turns = yield* Queue.unbounded<readonly [string, boolean]>();
const record = (id: string, active: boolean) => Queue.offerUnsafe(turns, [id, active]);
desktopTurns.on("turn", record);
yield* Effect.addFinalizer(() => Effect.sync(() => desktopTurns.off("turn", record)));
const endFirst = yield* activity.begin(threadId);
// An overlapping turn on the same thread neither starts nor ends focus on its own.
const endSecond = yield* activity.begin(threadId);
expect(yield* Queue.take(turns)).toEqual([threadId, true]);
yield* endFirst;
yield* endFirst;
expect(yield* activity.active(threadId)).toBe(true);
yield* endSecond;
expect(yield* Queue.take(turns)).toEqual([threadId, false]);
expect(yield* Queue.size(turns)).toBe(0);
}).pipe(Effect.scoped, Effect.provide(layer)),
);
it.live("preview_open reports its navigation timeout instead of the request budget", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const manager = yield* Manager.PreviewManager;
initialNavigation = async () => {
throw Object.assign(new Error("page.goto: Timeout 15000ms exceeded."), {
name: "TimeoutError",
});
};
const error = yield* broker
.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: {
url: "http://localhost:1337/",
reuseExistingTab: false,
show: false,
},
})
.pipe(Effect.flip);
expect(error).toMatchObject({
_tag: "PreviewAutomationTimeoutError",
timeoutMs: 15_000,
});
expect(error.message).toBe("Preview automation open timed out after 15000ms.");
// The failed open returned no tabId, so its tab must not linger and block later opens.
const { sessions } = yield* manager.list({ threadId: scope.thread.threadId });
expect(sessions.map((session) => session.tabId)).toEqual([tabId]);
expect(contexts[1]!.page.close).toHaveBeenCalled();
}),
).pipe(Effect.provide(layer)),
);
it.live("an initial download stays available after preview_open reports the navigation error", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const manager = yield* Manager.PreviewManager;
const released = Promise.withResolvers<void>();
initialNavigation = async () => {
contexts[1]!.page.emit("download", {
failure: async () => null,
delete: async () => released.resolve(),
saveAs: (path: string) => NodeFSP.writeFile(path, "a,b"),
suggestedFilename: () => "report.csv",
url: () => "http://localhost:1337/report.csv",
});
throw new Error("page.goto: Download is starting");
};
const error = yield* broker
.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: { url: "http://localhost:1337/report.csv", reuseExistingTab: false, open: false },
})
.pipe(Effect.flip);
expect(error.message).toContain("Download is starting");
yield* Effect.promise(() => released.promise);
const { sessions } = yield* manager.list({ threadId: scope.thread.threadId });
expect(sessions).toHaveLength(2);
const downloadTabId = PreviewTabId.make(sessions.find((tab) => tab.tabId !== tabId)!.tabId);
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId: downloadTabId,
operation: "status",
input: {},
});
expect(status.downloads).toEqual([
expect.objectContaining({ fileName: "report.csv", sizeBytes: 3 }),
]);
expect(yield* (yield* FileSystem.FileSystem).readFileString(status.downloads![0]!.path)).toBe(
"a,b",
);
}),
).pipe(Effect.provide(layer)),
);
it.live.each(["desktop" as const, undefined])(
"explicit desktop targets ($0 runtime) fail without creating a server tab",
(runtime) =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const manager = yield* Manager.PreviewManager;
const desktop = yield* manager.open({
threadId: scope.thread.threadId,
url: "https://example.com/original",
...(runtime === undefined ? {} : { runtime }),
});
const before = yield* manager.list({ threadId: scope.thread.threadId });
const error = yield* broker
.invoke<PreviewAutomationStatus>({
scope,
tabId: PreviewTabId.make(desktop.tabId),
operation: "open",
input: { url: "https://example.com/replacement", open: true },
})
.pipe(Effect.flip);
expect(error).toMatchObject({ _tag: "PreviewAutomationExecutionError" });
expect(error.message).toContain("desktop runtime");
expect(error.message).toContain("cannot control");
expect(yield* manager.list({ threadId: scope.thread.threadId })).toEqual(before);
expect(contexts).toHaveLength(1);
const reused = yield* broker.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: { open: false },
});
expect(reused.tabId).toBe(tabId);
}),
).pipe(Effect.provide(layer)),
);
it.effect("a tab the desktop does not draw is marked headless, so the desktop streams it", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const manager = yield* Manager.PreviewManager;
desktopRendersNext = true;
const desktopTab = yield* broker.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: { reuseExistingTab: false, show: false },
});
const { sessions } = yield* manager.list({ threadId: scope.thread.threadId });
const headlessOf = (id: string | null) =>
sessions.find((session) => session.tabId === id)?.headless;
expect(headlessOf(tabId)).toBe(true);
expect(headlessOf(desktopTab.tabId)).toBeUndefined();
}),
).pipe(Effect.provide(layer)),
);
it.effect("a desktop page that loaded before the server attached reports its loaded title", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker } = yield* ready;
const manager = yield* Manager.PreviewManager;
const events = yield* manager.subscribeEvents;
desktopRendersNext = true;
desktopPageUrl = "https://example.com/loaded";
const opened = yield* broker.invoke<PreviewAutomationStatus>({
scope,
operation: "open",
input: { url: desktopPageUrl, reuseExistingTab: false, show: false },
});
let event = yield* PubSub.take(events);
while (event.type !== "navigated" || event.tabId !== opened.tabId) {
event = yield* PubSub.take(events);
}
expect(event.snapshot.navStatus).toEqual({
_tag: "Success",
url: "https://example.com/loaded",
title: "test page",
});
}),
).pipe(Effect.provide(layer)),
);
it.live.each([
{ method: "goto" as const, message: { type: "navigate", url: "http://10.255.255.1/" } },
{ method: "goBack" as const, message: { type: "history", delta: -1 } },
{ method: "goForward" as const, message: { type: "history", delta: 1 } },
{ method: "reload" as const, message: { type: "reload" } },
])("a pending viewer $method allows a corrected URL and text input", ({ method, message }) =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
const started = Promise.withResolvers<void>();
const committed = Promise.withResolvers<void>();
const page = contexts[0]!.page;
page[method].mockImplementationOnce(() => {
started.resolve();
return committed.promise;
});
const navigation = yield* viewer.input(message).pipe(Effect.forkScoped);
yield* Effect.promise(() => started.promise);
const cdp = contexts[0]!.sessions.at(-1)!;
const send = cdp.send.getMockImplementation()!;
const typed = Promise.withResolvers<void>();
cdp.send.mockImplementation(async (operation, input) => {
if (operation === "Input.insertText") typed.resolve();
return send(operation, input);
});
const correction = yield* Effect.gen(function* () {
yield* viewer.input({ type: "navigate", url: "http://localhost:5173/fixed" });
yield* viewer.input({ type: "text", text: "hello" });
}).pipe(Effect.forkScoped);
yield* Effect.addFinalizer(() => Effect.sync(() => committed.resolve()));
// The text reaches the page while the first navigation is still uncommitted.
yield* Effect.promise(() => typed.promise);
expect(page.goto).toHaveBeenLastCalledWith(
"http://localhost:5173/fixed",
expect.objectContaining({ waitUntil: "commit" }),
);
expect(contexts[0]!.sessions.at(-1)!.send).toHaveBeenCalledWith("Input.insertText", {
text: "hello",
});
committed.resolve();
yield* Fiber.join(navigation);
yield* Fiber.join(correction);
}),
).pipe(Effect.provide(layer)),
);
// The fake encoder decodes every frame at 1280x800, so 30 fps hits the bitrate floor.
it.live.each([
{ reports: [], frameRate: 30, bitsPerSecond: 2.5e6 },
{ reports: [30], frameRate: 30, bitsPerSecond: 2.5e6 },
{ reports: [60], frameRate: 60, bitsPerSecond: 1280 * 800 * 60 * 0.05 },
{ reports: [60, undefined], frameRate: 60, bitsPerSecond: 1280 * 800 * 60 * 0.05 },
{ reports: [60, 30], frameRate: 30, bitsPerSecond: 2.5e6 },
] satisfies ReadonlyArray<{
reports: ReadonlyArray<BrowserRecordingFrameRate | undefined>;
frameRate: number;
bitsPerSecond: number;
}>)(
"agent recordings encode at the last reported frame rate ($reports)",
({ reports, frameRate, bitsPerSecond }) =>
Effect.scoped(
Effect.gen(function* () {
const { browser, broker, tabId } = yield* ready;
const reportProfiles = yield* browser.profileReporter;
for (const recordingFrameRate of reports) {
yield* reportProfiles({
profiles: [],
defaultProfileId: "default",
...(recordingFrameRate === undefined ? {} : { recordingFrameRate }),
});
}
yield* broker.invoke({ scope, tabId, operation: "recordingStart", input: {} });
expect(encoderStreams).toEqual([{ frameRate, bitsPerSecond }]);
}),
).pipe(Effect.provide(layer)),
);
it.live("enforces provider ownership and explicit targets when a session has multiple tabs", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const foreign = yield* broker
.invoke<void>({
scope: asSession("agent-b"),
tabId,
operation: "navigate",
input: { url: "http://localhost:5173/foreign" },
})
.pipe(Effect.flip);
expect(foreign).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "agentMismatch",
});
expect(contexts[0]!.page.goto).not.toHaveBeenCalledWith(
"http://localhost:5173/foreign",
expect.anything(),
);
yield* broker.invoke<PreviewAutomationSnapshot>({
scope: asSession("agent-b"),
tabId,
operation: "snapshot",
input: {},
});
const foreignEvaluate = yield* broker
.invoke<void>({
scope: asSession("agent-b"),
tabId,
operation: "evaluate",
input: { expression: "read()" },
})
.pipe(Effect.flip);
expect(foreignEvaluate).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "agentMismatch",
});
yield* broker.invoke({
scope,
operation: "open",
input: { reuseExistingTab: false, show: false },
});
const ambiguous = yield* broker
.invoke<void>({ scope, operation: "evaluate", input: { expression: "ambiguous()" } })
.pipe(Effect.flip);
expect(ambiguous).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "tabRequired",
});
const ambiguousStop = yield* broker
.invoke<void>({ scope, operation: "recordingStop", input: {} })
.pipe(Effect.flip);
expect(ambiguousStop).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "tabRequired",
});
const explicitStop = yield* broker
.invoke<void>({ scope, tabId, operation: "recordingStop", input: {} })
.pipe(Effect.flip);
expect(explicitStop).toMatchObject({
_tag: "PreviewAutomationExecutionError",
cause: { _tag: "PreviewAutomationRecordingNotActiveError" },
});
const result = yield* broker.invoke({
scope,
tabId,
operation: "evaluate",
input: { expression: "owned()" },
});
expect(result).toBe("evaluated");
expect(contexts).toHaveLength(2);
}),
).pipe(Effect.provide(layer)),
);
it.live("streams to a read-only viewer without allowing takeover, input, or viewport changes", () =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const viewer = yield* browser.attachViewer(viewerInput(tabId, false));
const page = contexts[0]!.page;
page.setViewportSize.mockClear();
const session = contexts[0]!.sessions.at(-1)!;
session.send.mockClear();
for (const message of [
{ type: "takeControl" },
{ type: "key", action: "down", key: "a", text: "a" },
{ type: "resize", width: 390, height: 844 },
{ type: "viewport", setting: { _tag: "freeform", width: 390, height: 844 } },
])
yield* viewer.input(message);
expect(page.setViewportSize).not.toHaveBeenCalled();
expect(session.send.mock.calls.some(([method]) => method.startsWith("Input."))).toBe(false);
const outputs = yield* Queue.takeAll(viewer.output);
expect(outputs).toContainEqual(
expect.objectContaining({ _tag: "frame", data: Buffer.from("frame") }),
);
expect(outputs).toContainEqual(expect.objectContaining({ _tag: "viewport" }));
expect(outputs).toContainEqual(
expect.objectContaining({ _tag: "control", canOperate: false, controller: "agent" }),
);
const operator = yield* browser.attachViewer(viewerInput(tabId, true));
yield* operator.input({ type: "takeControl" });
yield* operator.input({ type: "text", text: "typed" });
yield* operator.input({ type: "resize", width: 390, height: 844 });
expect(contexts[0]!.sessions.at(-1)!.send).toHaveBeenCalledWith("Input.insertText", {
text: "typed",
});
expect(page.setViewportSize).toHaveBeenCalledWith({ width: 390, height: 844 });
yield* operator.input({ type: "releaseControl" });
}),
).pipe(Effect.provide(layer)),
);
it.live(
"takeover waits for the running agent and revokes snapshot refs before returning control",
() =>
Effect.scoped(
Effect.gen(function* () {
const { browser, broker, tabId } = yield* ready;
const snapshot = yield* broker.invoke<PreviewAutomationSnapshot>({
scope,
tabId,
operation: "snapshot",
input: {},
});
const ref = /\[ref=([^\]]+)\]/.exec(String(snapshot.accessibilityTree))![1]!;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
const started = Promise.withResolvers<void>();
const finish = Promise.withResolvers<Record<string, unknown>>();
const session = contexts[0]!.sessions[0]!;
session.send.mockImplementationOnce(async () => {
started.resolve();
return finish.promise;
});
const running = yield* broker
.invoke({ scope, tabId, operation: "evaluate", input: { expression: "pending()" } })
.pipe(Effect.forkScoped);
yield* Effect.addFinalizer(() =>
Effect.sync(() => finish.resolve({ result: { value: "finished" } })),
);
yield* Effect.promise(() => started.promise);
const takeover = yield* viewer.input({ type: "takeControl" }).pipe(Effect.forkScoped);
let control = yield* Queue.take(viewer.output);
while (control._tag !== "control" || control.controller !== "you") {
control = yield* Queue.take(viewer.output);
}
const rejected = yield* broker
.invoke<void>({ scope, tabId, operation: "evaluate", input: { expression: "racing()" } })
.pipe(Effect.flip);
expect(rejected).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "humanControl",
});
finish.resolve({ result: { value: "finished" } });
expect(yield* Fiber.join(running)).toBe("finished");
yield* Fiber.join(takeover);
yield* viewer.input({ type: "releaseControl" });
const stale = yield* broker
.invoke<void>({ scope, tabId, operation: "click", input: { locator: `aria-ref=${ref}` } })
.pipe(Effect.flip);
expect(stale._tag).toBe("PreviewAutomationInvalidSelectorError");
expect(contexts[0]!.page.locator).not.toHaveBeenCalled();
expect(
yield* broker.invoke({
scope,
tabId,
operation: "evaluate",
input: { expression: "resumed()" },
}),
).toBe("evaluated");
}),
).pipe(Effect.provide(layer)),
);
it.live("reports a pending dialog without evaluating the page and resolves it explicitly", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const page = contexts[0]!.page;
yield* broker.invoke({
scope,
tabId,
operation: "navigate",
input: { url: "http://localhost:5173" },
});
const started = Promise.withResolvers<void>();
const resolvedEvaluation = Promise.withResolvers<Record<string, unknown>>();
const session = contexts[0]!.sessions[0]!;
const send = session.send.getMockImplementation()!;
session.send.mockImplementation(async (method, input) => {
if (method !== "Runtime.evaluate") return send(method, input);
started.resolve();
return resolvedEvaluation.promise;
});
const blockedAction = yield* broker
.invoke({
scope,
tabId,
operation: "evaluate",
input: { expression: 'confirm("Delete row?")' },
})
.pipe(Effect.forkScoped);
yield* Effect.addFinalizer(() =>
Effect.sync(() => resolvedEvaluation.resolve({ result: { value: true } })),
);
yield* Effect.promise(() => started.promise);
const dialog = {
type: () => "confirm",
message: () => "Delete row?",
defaultValue: () => "",
accept: vi.fn(async () => {
resolvedEvaluation.resolve({ result: { value: true } });
}),
dismiss: vi.fn(async () => {}),
};
page.emit("dialog", dialog);
page.title.mockClear();
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(status.dialog).toMatchObject({ type: "confirm", message: "Delete row?" });
expect(page.title).not.toHaveBeenCalled();
expect(dialog.dismiss).not.toHaveBeenCalled();
const reuse = yield* broker
.invoke<void>({
scope,
tabId,
operation: "open",
input: { url: "http://localhost:5173/other" },
})
.pipe(Effect.flip);
expect(reuse).toMatchObject({
_tag: "PreviewAutomationControlInterruptedError",
reason: "dialogPending",
});
expect(page.goto).toHaveBeenCalledTimes(1);
yield* broker.invoke({ scope, tabId, operation: "dialog", input: { accept: true } });
expect(yield* Fiber.join(blockedAction)).toBe(true);
expect(dialog.accept).toHaveBeenCalledTimes(1);
const resolved = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(resolved.dialog).toBeNull();
}),
).pipe(Effect.provide(layer)),
);
it.live("a tab opened to a file the browser cannot show reports the file to download", () =>
Effect.scoped(
Effect.gen(function* () {
const browser = yield* ServerBrowser.ServerBrowser;
const manager = yield* Manager.PreviewManager;
const events = yield* manager.subscribeEvents;
yield* Effect.yieldNow;
const opened = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
const viewer = yield* browser.attachViewer(viewerInput(opened.tabId, true));
const page = contexts[0]!.page;
const pdf = "https://example.com/paper.pdf";
const request = { url: () => pdf, method: () => "GET", isNavigationRequest: () => true };
page.emit("requestfailed", {
...request,
frame: () => page,
failure: () => ({ errorText: "net::ERR_ABORTED" }),
});
const saved = yield* Queue.unbounded<string>();
const written = Promise.withResolvers<void>();
page.emit("download", {
failure: async () => null,
delete: async () => {
// A new navigation during cleanup must not erase the settled download status.
page.emit("request", {
url: () => "https://example.com/next",
method: () => "GET",
isNavigationRequest: () => true,
frame: () => page,
});
},
saveAs: (path: string) => {
Queue.offerUnsafe(saved, path);
return written.promise;
},
suggestedFilename: () => "paper.pdf",
url: () => pdf,
});
const fs = yield* FileSystem.FileSystem;
yield* fs.writeFileString(yield* Queue.take(saved), "%PDF");
written.resolve();
const received = [];
let status;
do {
status = yield* PubSub.take(events);
received.push(status);
} while (
status.type !== "navigated" ||
status.snapshot.navStatus._tag !== "Loading" ||
status.snapshot.navStatus.url !== "https://example.com/next"
);
expect(received).toContainEqual(
expect.objectContaining({
type: "failed",
url: pdf,
download: { id: expect.any(String), fileName: "paper.pdf" },
}),
);
expect((yield* Queue.clear(viewer.output)).some((item) => item._tag === "download")).toBe(
false,
);
}),
).pipe(Effect.provide(layer)),
);
it.live(
"a late failure from a request that predates tracking leaves a newer navigation loading",
() =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const page = contexts[0]!.page;
const navigation = (url: string) => ({
url: () => url,
method: () => "GET",
isNavigationRequest: () => true,
frame: () => page,
failure: () => ({ errorText: "net::ERR_CONNECTION_REFUSED" }),
});
page.emit("request", navigation("https://example.com/next"));
// A popup's first request can start before the tab listens for requests.
page.emit("requestfailed", navigation("https://example.com/first"));
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(status.loading).toBe(true);
}),
).pipe(Effect.provide(layer)),
);
it.effect("a navigation that fails while a load reads its title keeps its failure", () =>
Effect.scoped(
Effect.gen(function* () {
const { tabId } = yield* ready;
const manager = yield* Manager.PreviewManager;
const events = yield* manager.subscribeEvents;
const page = contexts[0]!.page;
const heldTitle = Promise.withResolvers<string>();
page.title.mockImplementationOnce(() => heldTitle.promise);
yield* Effect.promise(() => page.goto("https://example.com/first"));
const failing = {
url: () => "https://example.com/missing",
method: () => "GET",
isNavigationRequest: () => true,
frame: () => page,
failure: () => ({ errorText: "net::ERR_NAME_NOT_RESOLVED" }),
};
page.emit("request", failing);
page.emit("requestfailed", failing);
heldTitle.resolve("Held");
// A load at the same await depth reports after the held one, so its Success marks the end.
page.emit("load");
const statuses: Array<string> = [];
while (!statuses.at(-1)?.startsWith("Success")) {
const event = yield* PubSub.take(events);
if (event.type === "failed" && event.tabId === tabId) {
statuses.push(`LoadFailed ${event.url}`);
} else if (event.type === "navigated" && event.tabId === tabId) {
const status = event.snapshot.navStatus;
if (status._tag === "Success") statuses.push(`Success ${status.title}`);
else if (status._tag === "Loading") statuses.push(`Loading ${status.url}`);
}
}
expect(statuses).toEqual([
"Loading https://example.com/missing",
"LoadFailed https://example.com/missing",
"Success test page",
]);
}),
).pipe(Effect.provide(layer)),
);
it.effect.each([
{
name: "hover burst before a click",
inputs: [
...Array.from({ length: 120 }, (_, x) => ({
type: "mouse",
action: "move",
x,
buttons: 0,
button: "none",
})),
{ type: "mouse", action: "down", x: 119, buttons: 1, button: "left" },
{ type: "mouse", action: "up", x: 119, buttons: 0, button: "left" },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseMoved", x: 119 },
{ type: "mousePressed", x: 119 },
{ type: "mouseReleased", x: 119 },
],
},
{
name: "wheel burst before a click",
inputs: [
...Array.from({ length: 120 }, () => ({
type: "wheel",
x: 100,
y: 200,
deltaX: 0,
deltaY: 12,
})),
{ type: "mouse", action: "down", x: 100, buttons: 1, button: "left" },
{ type: "mouse", action: "up", x: 100, buttons: 0, button: "left" },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseWheel", x: 100, y: 200, deltaX: 0, deltaY: 1440 },
{ type: "mousePressed", x: 100 },
{ type: "mouseReleased", x: 100 },
],
},
{
name: "modifier changes and drag points",
inputs: [
{ type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
{ type: "mouse", action: "move", x: 2, buttons: 0, button: "none", modifiers: 2 },
{ type: "mouse", action: "move", x: 3, buttons: 0, button: "none", modifiers: 2 },
{ type: "mouse", action: "down", x: 3, buttons: 1, button: "left" },
{ type: "mouse", action: "move", x: 4, buttons: 1, button: "left" },
{ type: "mouse", action: "move", x: 5, buttons: 1, button: "left" },
{ type: "mouse", action: "up", x: 5, buttons: 0, button: "left" },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseMoved", x: 1, modifiers: 0 },
{ type: "mouseMoved", x: 3, modifiers: 2 },
{ type: "mousePressed", x: 3 },
{ type: "mouseMoved", x: 4 },
{ type: "mouseMoved", x: 5 },
{ type: "mouseReleased", x: 5 },
],
},
{
name: "wheel and keyboard boundaries",
inputs: [
{ type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
{ type: "wheel", x: 1, deltaY: 20 },
{ type: "wheel", x: 1, deltaY: 30 },
{ type: "mouse", action: "move", x: 2, buttons: 0, button: "none" },
{ type: "key", action: "down", key: "a", code: "KeyA", text: "a" },
{ type: "mouse", action: "move", x: 3, buttons: 0, button: "none" },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseMoved", x: 1 },
{ type: "mouseWheel", deltaY: 50 },
{ type: "mouseMoved", x: 2 },
{ type: "keyDown", key: "a" },
{ type: "mouseMoved", x: 3 },
],
},
{
name: "wheel position, modifier and direction boundaries",
inputs: [
{ type: "wheel", x: 1, deltaX: 5, deltaY: 10 },
{ type: "wheel", x: 1, deltaX: 5, deltaY: 10 },
{ type: "wheel", x: 2, deltaY: 10 },
{ type: "wheel", x: 2, deltaY: 10, modifiers: 2 },
{ type: "wheel", x: 2, deltaY: -10, modifiers: 2 },
{ type: "wheel", x: 2, deltaY: -10, modifiers: 2 },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseWheel", x: 1, deltaX: 10, deltaY: 20, modifiers: 0 },
{ type: "mouseWheel", x: 2, deltaX: 0, deltaY: 10, modifiers: 0 },
{ type: "mouseWheel", x: 2, deltaY: 10, modifiers: 2 },
{ type: "mouseWheel", x: 2, deltaY: -20, modifiers: 2 },
],
},
{
name: "text, navigation and resize boundaries",
inputs: [
{ type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
{ type: "text", text: "typed" },
{ type: "mouse", action: "move", x: 2, buttons: 0, button: "none" },
{ type: "navigate", url: "http://localhost:5173/next" },
{ type: "mouse", action: "move", x: 3, buttons: 0, button: "none" },
{ type: "resize", width: 640, height: 480 },
{ type: "mouse", action: "move", x: 4, buttons: 0, button: "none" },
],
expected: [
{ type: "mouseMoved", x: -1 },
{ type: "mouseMoved", x: 1 },
{ text: "typed" },
{ type: "mouseMoved", x: 2 },
{ type: "mouseMoved", x: 3 },
{ type: "mouseMoved", x: 4 },
],
},
{
name: "ambiguous button fields",
inputs: [
{ type: "mouse", action: "move", x: 1, button: "none" },
{ type: "mouse", action: "move", x: 2, button: "none" },
{ type: "mouse", action: "move", x: 3, buttons: 0 },
{ type: "mouse", action: "move", x: 4, buttons: 0 },
],
expected: [-1, 1, 2, 3, 4].map((x) => ({ type: "mouseMoved", x })),
},
])("orders streamed input correctly for $name", (testCase) =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
const session = contexts[0]!.sessions.at(-1)!;
const send = session.send.getMockImplementation()!;
const started = Promise.withResolvers<void>();
const finish = Promise.withResolvers<void>();
yield* Effect.addFinalizer(() => Effect.sync(() => finish.resolve()));
session.send.mockClear();
session.send.mockImplementationOnce(async (method, input) => {
started.resolve();
await finish.promise;
return send(method, input);
});
const running = yield* viewer
.input({ type: "mouse", action: "move", x: -1, button: "none", buttons: 0 })
.pipe(Effect.forkScoped({ startImmediately: true }));
yield* Effect.promise(() => started.promise);
const waiting = yield* Effect.forEach(testCase.inputs, (input) =>
viewer.input(input).pipe(Effect.forkScoped({ startImmediately: true })),
);
finish.resolve();
yield* Effect.forEach([running, ...waiting], Fiber.join);
const dispatched = session.send.mock.calls.flatMap(([method, input]) =>
method.startsWith("Input.") ? [input] : [],
);
expect(dispatched).toHaveLength(testCase.expected.length);
expect(dispatched).toMatchObject(testCase.expected);
}),
).pipe(Effect.provide(layer)),
);
it.live("only the controlling viewer's copy and cut keys reach its clipboard", () =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const watcher = yield* browser.attachViewer(viewerInput(tabId, false));
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
const clipboard = (queue: typeof viewer.output) =>
Queue.clear(queue).pipe(
Effect.map((items) => items.filter((item) => item._tag === "clipboard")),
);
pageCopy = "unprompted";
yield* viewer.input({ type: "mouse", action: "move", x: 10, y: 10 });
yield* viewer.input({ type: "wheel", x: 10, y: 10, deltaY: 40 });
yield* viewer.input({ type: "key", action: "down", key: "v", code: "KeyV", modifiers: 4 });
yield* viewer.input({ type: "unknown" });
expect(yield* clipboard(viewer.output)).toEqual([]);
keyCopy = "copied";
yield* viewer.input({ type: "key", action: "down", key: "c", code: "KeyC", modifiers: 4 });
const cdp = contexts[0]!.sessions.at(-1)!;
expect(cdp.send).toHaveBeenCalledWith(
"Input.dispatchKeyEvent",
expect.objectContaining({ key: "c", commands: ["copy"] }),
);
expect(yield* clipboard(viewer.output)).toEqual([{ _tag: "clipboard", text: "copied" }]);
keyCopy = "cut";
yield* viewer.input({ type: "key", action: "down", key: "x", code: "KeyX", modifiers: 2 });
expect(yield* clipboard(viewer.output)).toEqual([{ _tag: "clipboard", text: "cut" }]);
pageCopy = "left over";
keyCopy = "";
yield* viewer.input({ type: "key", action: "down", key: "c", code: "KeyC", modifiers: 4 });
expect(yield* clipboard(viewer.output)).toEqual([]);
expect(yield* clipboard(watcher.output)).toEqual([]);
}),
).pipe(Effect.provide(layer)),
);
it.live.each([false, true])(
"a page download is saved, offered to the controller, and listed for the agent (delete fails: %s)",
(deleteFails) =>
Effect.scoped(
Effect.gen(function* () {
const { browser, broker, tabId } = yield* ready;
const page = contexts[0]!.page;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
yield* Queue.clear(viewer.output);
const fs = yield* FileSystem.FileSystem;
const original = `${yield* fs.makeTempDirectoryScoped()}/chromium-download`;
yield* fs.writeFileString(original, "a,b");
const released = Promise.withResolvers<void>();
page.emit("download", {
failure: async () => null,
delete: async () => {
try {
if (deleteFails) throw new Error("context closed");
await NodeFSP.rm(original);
} finally {
released.resolve();
}
},
saveAs: (path: string) => NodeFSP.copyFile(original, path),
suggestedFilename: () => "report.csv",
url: () => 'data:text/csv;charset="a,b",a b\'c',
});
let offered = yield* Queue.take(viewer.output);
while (offered._tag !== "download") offered = yield* Queue.take(viewer.output);
expect(offered).toMatchObject({ _tag: "download", fileName: "report.csv", sizeBytes: 3 });
yield* Effect.promise(() => released.promise);
expect(yield* fs.exists(original)).toBe(deleteFails);
const file = yield* browser.openDownload({
threadId: scope.thread.threadId,
tabId,
downloadId: offered.id,
});
expect(Option.isSome(file) && file.value.fileName).toBe("report.csv");
expect(yield* fs.readFileString(Option.getOrThrow(file).path)).toBe("a,b");
if ((yield* HostProcess.Platform) !== "win32") {
expect((yield* fs.stat(Option.getOrThrow(file).path)).mode & 0o777).toBe(0o600);
}
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(status.downloads).toEqual([
expect.objectContaining({
fileName: "report.csv",
sizeBytes: 3,
url: "data:text/csv,…",
}),
]);
expect(
Option.isNone(
yield* browser.openDownload({
threadId: scope.thread.threadId,
tabId,
downloadId: "guess",
}),
),
).toBe(true);
if ((yield* HostProcess.Platform) !== "win32") {
const folder = (yield* Path.Path).dirname(Option.getOrThrow(file).path);
yield* fs.chmod(folder, 0o755);
page.emit("download", {
failure: async () => null,
delete: async () => {},
saveAs: (path: string) => NodeFSP.writeFile(path, "c"),
suggestedFilename: () => "again.csv",
url: () => "https://example.test/again.csv",
});
let again = yield* Queue.take(viewer.output);
while (again._tag !== "download") again = yield* Queue.take(viewer.output);
expect((yield* fs.stat(folder)).mode & 0o777).toBe(0o700);
}
}),
).pipe(Effect.provide(layer)),
);
it.effect("a tab showing a data: page reports its URL without the content", () =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const sibling = yield* broker.invoke<PreviewAutomationStatus>({
scope: asSession("agent-b"),
operation: "open",
input: { reuseExistingTab: false, show: false },
});
yield* Effect.promise(() => contexts[1]!.page.goto("data:text/html,<p>SIBLING-SECRET</p>"));
const manager = yield* Manager.PreviewManager;
const events = yield* manager.subscribeEvents;
yield* Effect.promise(() => contexts[0]!.page.goto("data:text/html,<p>SECRET-KEY</p>"));
let event = yield* PubSub.take(events);
while (
event.type !== "navigated" ||
event.tabId !== tabId ||
event.snapshot.navStatus._tag !== "Success"
) {
event = yield* PubSub.take(events);
}
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(event.snapshot.navStatus).toMatchObject({ url: "data:text/html,…" });
expect(status.url).toBe("data:text/html,…");
expect(status.tabs?.find((entry) => entry.tabId === tabId)?.url).toBe("data:text/html,…");
expect(status.tabs?.find((entry) => entry.tabId === sibling.tabId)?.url).toBe(
"data:text/html,…",
);
expect(JSON.stringify([event, status])).not.toContain("SECRET-KEY");
expect(JSON.stringify([event, status])).not.toContain("SIBLING-SECRET");
}),
).pipe(Effect.provide(layer)),
);
it.live.each(["save failed", "oversized"])(
"a rejected download releases the original and keeps no saved copy (%s)",
(outcome) =>
Effect.scoped(
Effect.gen(function* () {
const { broker, tabId } = yield* ready;
const fs = yield* FileSystem.FileSystem;
const original = `${yield* fs.makeTempDirectoryScoped()}/chromium-download`;
yield* fs.writeFileString(original, "a,b");
let savedPath: string | undefined;
const released = Promise.withResolvers<void>();
contexts[0]!.page.emit("download", {
failure: async () => null,
delete: async () => {
await NodeFSP.rm(original);
released.resolve();
},
saveAs: async (path: string) => {
savedPath = path;
await NodeFSP.copyFile(original, path);
if (outcome === "save failed") throw new Error("save interrupted");
// A sparse file exercises the size limit without writing a GiB of data.
await NodeFSP.truncate(path, 1024 ** 3 + 1);
},
suggestedFilename: () => "report.csv",
url: () => "blob:http://localhost:5173/1",
});
yield* Effect.promise(() => released.promise);
expect(yield* fs.exists(original)).toBe(false);
if (savedPath !== undefined) expect(yield* fs.exists(savedPath)).toBe(false);
const status = yield* broker.invoke<PreviewAutomationStatus>({
scope,
tabId,
operation: "status",
input: {},
});
expect(status.downloads).toEqual([]);
}),
).pipe(Effect.provide(layer)),
);
it.live("a restarted server removes the previous run's downloads and keeps its profiles", () =>
Effect.scoped(
Effect.gen(function* () {
const { stateDir } = yield* ServerConfig.ServerConfig;
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const previousTab = path.join(stateDir, "server-browser", "downloads", "previous-tab");
const profile = path.join(stateDir, "server-browser", "profiles", "default");
yield* fs.makeDirectory(previousTab, { recursive: true });
yield* fs.makeDirectory(profile, { recursive: true });
yield* fs.writeFileString(path.join(previousTab, "report.csv"), "a,b");
yield* fs.writeFileString(path.join(profile, "Preferences"), "{}");
yield* Layer.build(ServerBrowser.layer);
expect(yield* fs.exists(previousTab)).toBe(false);
expect(yield* fs.readFileString(path.join(profile, "Preferences"))).toBe("{}");
}),
).pipe(Effect.provide(dependencies)),
);
it.live("a page's file picker goes to the controller and takes its uploaded files", () =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const page = contexts[0]!.page;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
const setFiles = vi.fn(async (_files: unknown) => {});
page.emit("filechooser", {
isMultiple: () => false,
element: () => fileChooserElement(".csv"),
setFiles,
});
let offered = yield* Queue.take(viewer.output);
while (offered._tag !== "fileChooser") offered = yield* Queue.take(viewer.output);
expect(offered).toMatchObject({ multiple: false, accept: ".csv" });
const file = (name: string) => ({ name, mimeType: "text/csv", buffer: Buffer.from(name) });
const answer = (chooserId: string) =>
browser.answerFileChooser({
threadId: scope.thread.threadId,
tabId,
chooserId,
files: [file("a.csv"), file("b.csv")],
});
expect(yield* answer("other")).toBe(false);
expect(yield* answer(offered.id)).toBe(true);
expect(setFiles).toHaveBeenCalledExactlyOnceWith([file("a.csv")]);
let closed = yield* Queue.take(viewer.output);
while (closed._tag !== "fileChooserClosed") closed = yield* Queue.take(viewer.output);
expect(closed.id).toBe(offered.id);
expect(yield* answer(offered.id)).toBe(false);
}),
).pipe(Effect.provide(layer)),
);
it.live("overlapping file pickers keep the newer offer answerable", () =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const page = contexts[0]!.page;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
const accept = Promise.withResolvers<string | null>();
const firstFiles = vi.fn(async (_files: unknown) => {});
const secondFiles = vi.fn(async (_files: unknown) => {});
page.emit("filechooser", {
isMultiple: () => false,
element: () => ({ ...fileChooserElement(""), getAttribute: () => accept.promise }),
setFiles: firstFiles,
});
page.emit("filechooser", {
isMultiple: () => false,
element: () => fileChooserElement(".csv"),
setFiles: secondFiles,
});
accept.resolve(".txt");
let first = yield* Queue.take(viewer.output);
while (first._tag !== "fileChooser") first = yield* Queue.take(viewer.output);
let second = yield* Queue.take(viewer.output);
while (second._tag !== "fileChooser") second = yield* Queue.take(viewer.output);
expect(second.accept).toBe(".csv");
expect(
yield* browser.answerFileChooser({
threadId: scope.thread.threadId,
tabId,
chooserId: second.id,
files: [{ name: "a.csv", mimeType: "text/csv", buffer: Buffer.from("a") }],
}),
).toBe(true);
expect(firstFiles).not.toHaveBeenCalled();
expect(secondFiles).toHaveBeenCalledOnce();
}),
).pipe(Effect.provide(layer)),
);
it.live("a detached file picker stays open across same-document navigation", () =>
Effect.scoped(
Effect.gen(function* () {
const { browser, tabId } = yield* ready;
const page = contexts[0]!.page;
const pageDocument = {};
vi.stubGlobal("document", pageDocument);
yield* Effect.addFinalizer(() => Effect.sync(() => vi.unstubAllGlobals()));
const detachedInput = { isConnected: false, ownerDocument: pageDocument };
const navigationProbe = Promise.withResolvers<boolean>();
const navigationProbeStarted = Promise.withResolvers<void>();
const navigationProbeFinished = Promise.withResolvers<void>();
let probeCount = 0;
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
yield* viewer.input({ type: "takeControl" });
page.emit("filechooser", {
isMultiple: () => false,
element: () => ({
getAttribute: async () => "",
evaluate: (probe: (element: typeof detachedInput) => boolean) => {
probeCount++;
if (probeCount === 1) return Promise.resolve(probe(detachedInput));
navigationProbeStarted.resolve();
return navigationProbe.promise.then((current) => {
const result = probe(detachedInput);
navigationProbeFinished.resolve();
return current && result;
});
},
}),
setFiles: vi.fn(async (_files: unknown) => {}),
});
let offered = yield* Queue.take(viewer.output);
while (offered._tag !== "fileChooser") offered = yield* Queue.take(viewer.output);
page.emit("framenavigated", page);
yield* Effect.promise(() => navigationProbeStarted.promise);
navigationProbe.resolve(true);
yield* Effect.promise(() => navigationProbeFinished.promise);
yield* viewer.input({ type: "releaseControl" });
let closedAfterNavigation = false;
let control = yield* Queue.take(viewer.output);
while (control._tag !== "control" || control.controller === "you") {
if (control._tag === "fileChooserClosed") closedAfterNavigation = true;
control = yield* Queue.take(viewer.output);
}
expect(closedAfterNavigation).toBe(false);
yield* viewer.input({ type: "takeControl" });
let restoredControl = yield* Queue.take(viewer.output);
while (restoredControl._tag !== "control" || restoredControl.controller !== "you") {
restoredControl = yield* Queue.take(viewer.output);
}
expect(