Skip to content

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.

11.8 KB
Raw Blame
import { it as effectIt } from "@effect/vitest";

import * as Effect from "effect/Effect";

import * as Exit from "effect/Exit";

import { beforeEach, describe, expect, vi } from "vite-plus/test";

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 } = 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();
  });

  const makeAudioWebContents = (id: number) => {
    const listeners = new Map<string, (...args: never[]) => void>();
    const setAudioMuted = vi.fn();
    let audible = false;
    let audibleAfterFirstRead = false;
    let audibleReads = 0;

    return {
      setAudioMuted,
      emitAudioState: (next: boolean) => {
        audible = next;
        listeners.get("audio-state-changed")?.({ audible: next } as never);
      },
      /**
       * Starts playing between the attach-time read and the post-attach
       * reconcile, without a delivered event — the window in which
       * audio-state-changed fires against a guest the tab does not own yet.
       */
      startPlayingAfterFirstRead: () => {
        audibleAfterFirstRead = true;
      },
      wc: {
        id,
        isDestroyed: () => false,
        isDevToolsOpened: () => false,
        getType: () => "webview",
        getURL: () => "https://example.com",
        getTitle: () => "Example",
        isLoading: () => false,
        getZoomFactor: () => 1,
        setZoomFactor: vi.fn(),
        setAudioMuted,
        isCurrentlyAudible: () => {
          audibleReads += 1;

          if (audibleAfterFirstRead && audibleReads > 1) return true;

          return audible;
        },
        loadURL: vi.fn(async () => undefined),
        on: vi.fn((event: string, listener: (...args: never[]) => void) => {
          listeners.set(event, listener);
        }),
        off: vi.fn((event: string) => {
          listeners.delete(event);
        }),
        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,
    };
  };

  effectIt.effect("mutes the guest and re-applies the mute across webview swaps", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const first = makeAudioWebContents(42);
        fromId.mockReturnValue(first.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audio");
        yield* manager.registerWebview("tab_audio", 42);
        yield* Effect.yieldNow;

        expect(states.at(-1)?.audioMuted).toBe(false);

        yield* manager.setAudioMuted("tab_audio", true);

        expect(first.setAudioMuted).toHaveBeenCalledWith(true);
        expect(states.at(-1)?.audioMuted).toBe(true);

        const replacement = makeAudioWebContents(43);
        fromId.mockReturnValue(replacement.wc);
        yield* manager.registerWebview("tab_audio", 43);
        yield* Effect.yieldNow;

        expect(replacement.setAudioMuted).toHaveBeenCalledWith(true);
        expect(states.at(-1)?.audioMuted).toBe(true);

        yield* manager.setAudioMuted("tab_audio", false);

        expect(replacement.setAudioMuted).toHaveBeenLastCalledWith(false);
        expect(states.at(-1)?.audioMuted).toBe(false);
      }),
    ),
  );

  effectIt.effect("fails and rolls back when the guest refuses a mute", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const guest = makeAudioWebContents(42);
        fromId.mockReturnValue(guest.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audio_fail");
        yield* manager.registerWebview("tab_audio_fail", 42);
        yield* Effect.yieldNow;

        guest.setAudioMuted.mockImplementationOnce(() => {
          throw new Error("guest refused");
        });
        const exit = yield* manager.setAudioMuted("tab_audio_fail", true).pipe(Effect.exit);

        // Reporting success would draw the tab as muted while it keeps playing.
        expect(Exit.isFailure(exit)).toBe(true);
        expect(states.at(-1)?.audioMuted).toBe(false);
      }),
    ),
  );

  effectIt.effect("still registers a guest that refuses the mute reassert", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const first = makeAudioWebContents(42);
        fromId.mockReturnValue(first.wc);
        yield* manager.createTab("tab_audio_attach_fail");
        yield* manager.registerWebview("tab_audio_attach_fail", 42);
        yield* Effect.yieldNow;
        yield* manager.setAudioMuted("tab_audio_attach_fail", true);

        const replacement = makeAudioWebContents(43);
        // Fails the post-attach settle, not the pre-publish apply.
        replacement.setAudioMuted.mockImplementationOnce(() => undefined);
        replacement.setAudioMuted.mockImplementationOnce(() => {
          throw new Error("guest went away");
        });
        fromId.mockReturnValue(replacement.wc);

        // Reconciliation is best-effort: a guest dying mid-attach must not fail
        // the registration it was attaching for.
        const exit = yield* manager.registerWebview("tab_audio_attach_fail", 43).pipe(Effect.exit);
        expect(Exit.isSuccess(exit)).toBe(true);
      }),
    ),
  );

  effectIt.effect("reconciles audibility that changed while the guest attached", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const guest = makeAudioWebContents(42);
        guest.startPlayingAfterFirstRead();
        fromId.mockReturnValue(guest.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audio_window");
        yield* manager.registerWebview("tab_audio_window", 42);
        yield* Effect.yieldNow;

        // audio-state-changed for this transition was dropped: it fired before
        // the tab owned the guest. Without a post-attach reconcile the icon
        // stays wrong until the next real transition, which may never come.
        expect(states.at(-1)?.audible).toBe(true);
      }),
    ),
  );

  effectIt.effect("publishes audibility transitions and drops repeats", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const guest = makeAudioWebContents(42);
        fromId.mockReturnValue(guest.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audible");
        yield* manager.registerWebview("tab_audible", 42);
        yield* Effect.yieldNow;

        expect(states.at(-1)?.audible).toBe(false);

        guest.emitAudioState(true);
        yield* Effect.yieldNow;
        expect(states.at(-1)?.audible).toBe(true);

        // Chromium re-emits per media element; only real transitions publish.
        const publishedAfterFirst = states.length;
        guest.emitAudioState(true);
        yield* Effect.yieldNow;
        expect(states.length).toBe(publishedAfterFirst);

        guest.emitAudioState(false);
        yield* Effect.yieldNow;
        expect(states.at(-1)?.audible).toBe(false);
        expect(states.length).toBeGreaterThan(publishedAfterFirst);
      }),
    ),
  );

  effectIt.effect("ignores audio state from a replaced guest", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const first = makeAudioWebContents(42);
        fromId.mockReturnValue(first.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audio_stale");
        yield* manager.registerWebview("tab_audio_stale", 42);
        yield* Effect.yieldNow;

        const replacement = makeAudioWebContents(43);
        fromId.mockReturnValue(replacement.wc);
        yield* manager.registerWebview("tab_audio_stale", 43);
        yield* Effect.yieldNow;

        const publishedBefore = states.length;
        first.emitAudioState(true);
        yield* Effect.yieldNow;

        expect(states.length).toBe(publishedBefore);
        expect(states.at(-1)?.audible).toBe(false);
      }),
    ),
  );

  effectIt.effect("carries mute and audibility across navigation", () =>
    withManager((manager) =>
      Effect.gen(function* () {
        const guest = makeAudioWebContents(42);
        fromId.mockReturnValue(guest.wc);
        const states: PreviewManager.PreviewTabState[] = [];

        yield* manager.subscribeStateChanges((_tabId, state) =>
          Effect.sync(() => {
            states.push(state);
          }),
        );
        yield* manager.createTab("tab_audio_nav");
        yield* manager.registerWebview("tab_audio_nav", 42);
        yield* Effect.yieldNow;

        yield* manager.setAudioMuted("tab_audio_nav", true);
        guest.emitAudioState(true);
        yield* Effect.yieldNow;
        expect(states.at(-1)?.audible).toBe(true);

        yield* manager.navigate("tab_audio_nav", "https://example.com/next");
        yield* Effect.yieldNow;

        // navigate runs before loadURL swaps the document, so the old page can
        // still be playing. Dropping audibility here would lose the speaker
        // with no transition left to bring it back.
        expect(states.at(-1)?.audioMuted).toBe(true);
        expect(states.at(-1)?.audible).toBe(true);

        // Chromium reports the real stop once the new document takes over.
        guest.emitAudioState(false);
        yield* Effect.yieldNow;
        expect(states.at(-1)?.audible).toBe(false);
      }),
    ),
  );
});