Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import { it as effectIt } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Logger from "effect/Logger";
import * as Option from "effect/Option";
import { beforeEach, describe, expect, vi } from "vite-plus/test";
import * as ElectronWindow from "../electron/ElectronWindow.ts";
import * as PreviewManager from "./Manager.ts";
import { createPreviewManagerHarness } from "./test-support/PreviewManagerHarness.ts";
const {
browserWindowConstructor,
createFromBuffer,
createFromPath,
fromId,
getFocusedWebContents,
mkdir,
showItemInFolder,
webviewSend,
writeFile,
writeImage,
} = vi.hoisted(() => ({
browserWindowConstructor: vi.fn(),
createFromBuffer: vi.fn(),
createFromPath: vi.fn((): Pick<Electron.NativeImage, "isEmpty"> => ({ isEmpty: () => false })),
fromId: vi.fn((_id?: number): Electron.WebContents | null => null),
getFocusedWebContents: vi.fn((): Electron.WebContents | null => null),
mkdir: vi.fn((_path: string) => undefined),
showItemInFolder: vi.fn(),
webviewSend: vi.fn(),
writeFile: vi.fn((_path: string, _data: Uint8Array) => undefined),
writeImage: vi.fn(),
}));
vi.mock("electron", () => ({
BrowserWindow: browserWindowConstructor,
clipboard: {
writeImage,
},
nativeImage: {
createFromBuffer,
createFromPath,
},
shell: {
showItemInFolder,
},
session: {
fromPartition: vi.fn(),
},
webContents: {
fromId,
getFocusedWebContents,
},
}));
const {
withManager,
makeTestPreviewWebContents,
makeFaviconWebContents,
makeTestPictureInPictureWindow,
} = createPreviewManagerHarness({
browserWindowConstructor,
createFromBuffer,
createFromPath,
fromId,
getFocusedWebContents,
mkdir,
showItemInFolder,
webviewSend,
writeFile,
writeImage,
});
describe("PreviewManager", () => {
beforeEach(() => {
browserWindowConstructor.mockReset();
fromId.mockClear();
getFocusedWebContents.mockReset();
getFocusedWebContents.mockReturnValue(null);
mkdir.mockClear();
writeFile.mockClear();
showItemInFolder.mockClear();
writeImage.mockClear();
createFromPath.mockClear();
createFromBuffer.mockReset();
webviewSend.mockClear();
});
effectIt.effect("reports an unregistered webview as temporarily unavailable", () =>
withManager((manager) =>
Effect.gen(function* () {
expect(yield* manager.automationStatus("tab_1")).toEqual({
available: false,
visible: true,
tabId: "tab_1",
url: null,
title: null,
loading: false,
});
yield* manager.createTab("tab_1");
expect(yield* manager.automationStatus("tab_1")).toEqual({
available: false,
visible: true,
tabId: "tab_1",
url: null,
title: null,
loading: false,
});
expect(fromId).not.toHaveBeenCalled();
}),
),
);
effectIt.effect("rejects a destroyed webview during registration", () =>
withManager((manager) =>
Effect.gen(function* () {
const getType = vi.fn(() => "webview" as const);
fromId.mockReturnValue({
id: 42,
isDestroyed: () => true,
getType,
} as never);
yield* manager.createTab("tab_destroyed_registration");
const exit = yield* Effect.exit(manager.registerWebview("tab_destroyed_registration", 42));
expect(Exit.isFailure(exit)).toBe(true);
if (Exit.isFailure(exit)) {
expect(Option.getOrThrow(Cause.findErrorOption(exit.cause))).toMatchObject({
_tag: "PreviewWebContentsNotFoundError",
tabId: "tab_destroyed_registration",
webContentsId: 42,
});
}
expect(getType).not.toHaveBeenCalled();
}),
),
);
effectIt.effect("isolates failed state listeners and continues delivery", () => {
const loggedErrors: Array<unknown> = [];
const logger = Logger.make(({ message }) => {
for (const value of Array.isArray(message) ? message : [message]) {
if (Predicate.isObjectOrArray(value) && value !== null && "cause" in value) {
loggedErrors.push(Cause.squash(value.cause as Cause.Cause<never>));
}
}
});
const deliveryError = new ElectronWindow.ElectronWindowOperationError({
operation: "send-window-message",
platform: "darwin",
windowId: 42,
channel: "preview:state-change",
cause: new Error("renderer unavailable"),
});
const delivered = vi.fn();
return withManager((manager) =>
Effect.gen(function* () {
yield* manager.subscribeStateChanges(() => Effect.die(deliveryError));
yield* manager.subscribeStateChanges((tabId, state) =>
Effect.sync(() => {
delivered(tabId, state);
}),
);
const state = yield* manager.createTab("tab_listener_failure");
expect(delivered).toHaveBeenCalledOnce();
expect(delivered).toHaveBeenCalledWith("tab_listener_failure", state);
expect(loggedErrors).toHaveLength(1);
expect(loggedErrors[0]).toBeInstanceOf(ElectronWindow.ElectronWindowOperationError);
expect(loggedErrors[0]).toMatchObject({
operation: "send-window-message",
windowId: 42,
channel: "preview:state-change",
});
}),
).pipe(
Effect.provide(
Logger.layer([logger], {
mergeWithExisting: false,
}),
),
);
});
effectIt.effect("does not swallow state listener interruption", () =>
withManager((manager) =>
Effect.gen(function* () {
const exit = yield* Effect.scoped(
Effect.gen(function* () {
yield* manager.subscribeStateChanges(() => Effect.interrupt);
return yield* Effect.exit(manager.createTab("tab_interrupted_listener"));
}),
);
expect(Exit.isFailure(exit)).toBe(true);
if (Exit.isFailure(exit)) {
expect(Cause.hasInterrupts(exit.cause)).toBe(true);
}
}),
),
);
effectIt.effect("queues navigation until the webview registers", () =>
withManager((manager) =>
Effect.gen(function* () {
const loadURL = vi.fn(async () => undefined);
const listeners = new Map<string, (...args: never[]) => void>();
fromId.mockReturnValue({
id: 42,
isDestroyed: () => false,
getType: () => "webview",
getURL: () => "about:blank",
getTitle: () => "",
isLoading: () => false,
getZoomFactor: () => 1,
setZoomFactor: vi.fn(),
setAudioMuted: vi.fn(),
isCurrentlyAudible: () => false,
loadURL,
on: vi.fn((event: string, listener: (...args: never[]) => void) => {
listeners.set(event, listener);
}),
off: vi.fn(),
ipc: { on: vi.fn(), off: vi.fn() },
send: webviewSend,
navigationHistory: { canGoBack: () => false, canGoForward: () => false },
setIgnoreMenuShortcuts: vi.fn(),
setWindowOpenHandler: vi.fn(),
debugger: {
isAttached: () => false,
attach: vi.fn(),
sendCommand: vi.fn(async () => undefined),
on: vi.fn(),
off: vi.fn(),
},
} as never);
yield* manager.navigate("tab_pending", "localhost:3200");
expect(yield* manager.automationStatus("tab_pending")).toEqual({
available: false,
visible: true,
tabId: "tab_pending",
url: "http://localhost:3200/",
title: "",
loading: true,
});
yield* manager.registerWebview("tab_pending", 42);
yield* Effect.yieldNow;
expect(loadURL).toHaveBeenCalledOnce();
expect(loadURL).toHaveBeenCalledWith("http://localhost:3200/");
}),
),
);
effectIt.effect("detaches a destroyed webview instead of navigating it", () =>
withManager((manager) =>
Effect.gen(function* () {
const preview = makeFaviconWebContents();
fromId.mockReturnValue(preview.webContents);
const states: PreviewManager.PreviewTabState[] = [];
yield* manager.subscribeStateChanges((_tabId, state) =>
Effect.sync(() => {
states.push(state);
}),
);
yield* manager.createTab("tab_destroyed_navigation");
yield* manager.registerWebview("tab_destroyed_navigation", 42);
yield* manager.setColorScheme("tab_destroyed_navigation", "dark");
preview.setDestroyed(true);
yield* manager.navigate("tab_destroyed_navigation", "https://example.com/");
expect(preview.loadURL).not.toHaveBeenCalled();
expect(preview.reload).not.toHaveBeenCalled();
expect(preview.off).toHaveBeenCalled();
expect(preview.debuggerOff).toHaveBeenCalled();
expect(states.at(-1)).toMatchObject({
webContentsId: null,
navStatus: { kind: "Loading", url: "https://example.com/" },
});
}),
),
);
effectIt.effect("blocks late webview and capture starts during tab close", () =>
withManager((manager) =>
Effect.gen(function* () {
const capturePage = vi.fn(async () => ({
toJPEG: () => Buffer.from("close-race-frame"),
getSize: () => ({ width: 1280, height: 720 }),
}));
const firstWebContents = makeTestPreviewWebContents(capturePage, 42);
const replacementWebContents = makeTestPreviewWebContents(capturePage, 43);
const replacementListenerSpies = {
on: vi.mocked(replacementWebContents.on),
off: vi.mocked(replacementWebContents.off),
ipc: { off: vi.mocked(replacementWebContents.ipc.off) },
};
fromId.mockImplementation((id) => {
if (id === 42) return firstWebContents;
if (id === 43) return replacementWebContents;
return null;
});
const { pictureInPictureWindow } = makeTestPictureInPictureWindow();
browserWindowConstructor.mockImplementation(function () {
return pictureInPictureWindow;
});
yield* manager.createTab("tab_close_register_race");
yield* manager.registerWebview("tab_close_register_race", 42);
yield* manager.openPictureInPicture("tab_close_register_race");
const closeCleanupPaused = yield* Deferred.make<void>();
const continueCloseCleanup = yield* Deferred.make<void>();
yield* manager.subscribeStateChanges((_tabId, state) =>
!state.pictureInPicture && state.webContentsId === 42
? Deferred.succeed(closeCleanupPaused, undefined).pipe(
Effect.andThen(Deferred.await(continueCloseCleanup)),
)
: Effect.void,
);
const closeFiber = yield* manager
.closeTab("tab_close_register_race")
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(closeCleanupPaused);
const recreateFiber = yield* manager
.createTab("tab_close_register_race")
.pipe(Effect.forkChild({ startImmediately: true }));
const registrationFiber = yield* manager
.registerWebview("tab_close_register_race", 43)
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Effect.yieldNow;
expect(replacementListenerSpies.on).not.toHaveBeenCalled();
yield* manager.closeTab("tab_close_register_race");
const recordingExit = yield* Effect.exit(manager.startRecording("tab_close_register_race"));
yield* Deferred.succeed(continueCloseCleanup, undefined);
yield* Fiber.join(closeFiber);
const recreated = yield* Fiber.join(recreateFiber);
const registrationExit = yield* Fiber.await(registrationFiber);
for (const exit of [registrationExit, recordingExit]) {
expect(Exit.isFailure(exit)).toBe(true);
if (Exit.isSuccess(exit)) continue;
expect(Option.getOrThrow(Cause.findErrorOption(exit.cause))).toMatchObject({
_tag: "PreviewTabNotFoundError",
tabId: "tab_close_register_race",
});
}
expect(replacementListenerSpies.on).not.toHaveBeenCalled();
expect(replacementListenerSpies.off).not.toHaveBeenCalled();
expect(replacementListenerSpies.ipc.off).not.toHaveBeenCalled();
expect(capturePage).toHaveBeenCalledOnce();
expect(recreated.webContentsId).toBeNull();
}),
),
);
effectIt.effect("keeps a main-frame load failure visible until a retry starts", () =>
withManager((manager) =>
Effect.gen(function* () {
const url = "http://localhost:5733/";
let loading = false;
const listeners = new Map<string, (...args: unknown[]) => void>();
fromId.mockReturnValue({
id: 42,
isDestroyed: () => false,
getType: () => "webview",
getURL: () => url,
getTitle: () => "localhost:5733",
isLoading: () => loading,
getZoomFactor: () => 1,
setZoomFactor: vi.fn(),
setAudioMuted: vi.fn(),
isCurrentlyAudible: () => false,
on: vi.fn((event: string, listener: (...args: unknown[]) => void) => {
listeners.set(event, listener);
}),
off: vi.fn(),
ipc: { on: vi.fn(), off: vi.fn() },
send: webviewSend,
navigationHistory: { canGoBack: () => false, canGoForward: () => false },
setIgnoreMenuShortcuts: vi.fn(),
setWindowOpenHandler: vi.fn(),
debugger: {
isAttached: () => false,
attach: vi.fn(),
sendCommand: vi.fn(async () => undefined),
on: vi.fn(),
off: vi.fn(),
},
} as never);
const statuses: PreviewManager.PreviewNavStatus[] = [];
yield* manager.subscribeStateChanges((_tabId, state) =>
Effect.sync(() => {
statuses.push(state.navStatus);
}),
);
yield* manager.createTab("tab_failed");
yield* manager.registerWebview("tab_failed", 42);
listeners.get("did-fail-load")?.(
{},
-105,
"ERR_NAME_NOT_RESOLVED",
"https://missing-frame.example/",
false,
);
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("Success");
loading = true;
listeners.get("did-start-loading")?.();
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("Loading");
loading = false;
listeners.get("did-fail-load")?.({}, -102, "ERR_CONNECTION_REFUSED", url, true);
listeners.get("did-stop-loading")?.();
listeners.get("page-title-updated")?.();
yield* Effect.yieldNow;
expect(statuses.at(-1)).toEqual({
kind: "LoadFailed",
url,
title: "localhost:5733",
code: -102,
description: "ERR_CONNECTION_REFUSED",
});
loading = true;
listeners.get("did-start-loading")?.();
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("Loading");
loading = false;
listeners.get("did-stop-loading")?.();
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("Success");
listeners.get("did-fail-load")?.({}, -102, "ERR_CONNECTION_REFUSED", url, true);
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("LoadFailed");
listeners.get("did-navigate")?.();
yield* Effect.yieldNow;
expect(statuses.at(-1)?.kind).toBe("Success");
}),
),
);
});