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.

10.8 KB
Raw Blame
import { assert, describe, it } from "@effect/vitest";

import * as Effect from "effect/Effect";

import * as Option from "effect/Option";

import * as Queue from "effect/Queue";

import * as Ref from "effect/Ref";

import * as NodeEvents from "node:events";

import type * as Electron from "electron";

import { vi } from "vite-plus/test";

import * as ElectronMenu from "../electron/ElectronMenu.ts";

import { WINDOW_FULLSCREEN_STATE_CHANNEL } from "../ipc/channels.ts";

import * as DesktopWindow from "./DesktopWindow.ts";

import { makeFakeBrowserWindow, makeTestLayer } from "./test-support/DesktopWindowHarness.ts";

describe("DesktopWindow", () => {
  it("leaves fullscreen before concealing a pending quit", () => {
    const fakeWindow = makeFakeBrowserWindow();

    DesktopWindow.concealPendingQuitWindow(fakeWindow.window);
    assert.deepEqual(fakeWindow.setOpacity.mock.calls, [[0]]);

    fakeWindow.setOpacity.mockClear();
    fakeWindow.isFullScreen.mockReturnValue(true);
    DesktopWindow.concealPendingQuitWindow(fakeWindow.window);
    assert.deepEqual(fakeWindow.setFullScreen.mock.calls, [[false]]);
    assert.deepEqual(fakeWindow.setOpacity.mock.calls, [[0]]);

    fakeWindow.setOpacity.mockClear();
    fakeWindow.isFullScreen.mockReturnValue(false);
    fakeWindow.isDestroyed.mockReturnValue(true);
    DesktopWindow.concealPendingQuitWindow(fakeWindow.window);
    assert.equal(fakeWindow.setOpacity.mock.calls.length, 0);
  });

  it.effect("shows native context menus for browser guests and sign-in popups", () =>
    Effect.gen(function* () {
      const host = makeFakeBrowserWindow();
      const popup = makeFakeBrowserWindow();
      let focusedContents: unknown = host.window.webContents;

      const makeContents = () => {
        const contents = Object.assign(new NodeEvents.EventEmitter(), {
          isDestroyed: vi.fn(() => false),
          focus: vi.fn(() => {
            focusedContents = contents;
          }),
          copyImageAt: vi.fn(),
          replaceMisspelling: vi.fn(),
        });

        return contents;
      };

      const guest = makeContents();
      const popupContents = makeContents();
      const popupWindow = { ...popup.window, webContents: popupContents };

      const menus = yield* Queue.unbounded<{
        input: ElectronMenu.ElectronMenuTemplateInput;
        focusedContents: unknown;
      }>();

      const copiedTexts: string[] = [];

      const layer = makeTestLayer({
        window: host.window,
        createCount: yield* Ref.make(0),
        mainWindow: yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none()),
        copiedTexts,
        onPopupTemplate: (input) =>
          Queue.offer(menus, { input, focusedContents }).pipe(Effect.asVoid),
      });

      yield* Effect.gen(function* () {
        const desktopWindow = yield* DesktopWindow.DesktopWindow;
        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
        const attach = host.webContentsListeners.get("did-attach-webview");
        assert.isDefined(attach);
        attach({}, guest);
        attach({}, guest);
        guest.emit("did-create-window", popupWindow);
        guest.emit("did-create-window", popupWindow);

        for (const [contents, owner] of [
          [guest, host.window],
          [popupContents, popupWindow],
        ] as const) {
          const frame = { routingId: 7 } as Electron.WebFrameMain;
          const preventDefault = vi.fn();

          const params = {
            frame,
            x: 12,
            y: 34,
            misspelledWord: "helo",
            dictionarySuggestions: ["hello"],
            linkURL: "",
            mediaType: "none",
            editFlags: { canCut: false, canCopy: true, canPaste: true, canSelectAll: true },
          };

          focusedContents = host.window.webContents;
          contents.emit("context-menu", { preventDefault }, params);
          const menu = yield* Queue.take(menus);
          assert.strictEqual(menu.input.window, owner);
          assert.strictEqual(menu.input.frame, frame);
          assert.strictEqual(menu.focusedContents, contents);
          assert.equal(preventDefault.mock.calls.length, 1);
          assert.deepEqual(
            menu.input.template.filter((item) => item.role),
            [
              { role: "cut", enabled: false },
              { role: "copy", enabled: true },
              { role: "paste", enabled: true },
              { role: "selectAll", enabled: true },
            ],
          );
          const correction = menu.input.template.find((item) => item.label === "hello");
          assert.isDefined(correction?.click);
          correction.click({} as Electron.MenuItem, undefined, {} as Electron.KeyboardEvent);
          assert.deepEqual(contents.replaceMisspelling.mock.calls, [["hello"]]);

          contents.emit(
            "context-menu",
            { preventDefault },
            {
              ...params,
              frame: null,
              misspelledWord: "",
              dictionarySuggestions: [],
              mediaType: "image",
              linkURL: "https://example.com/image.png",
            },
          );
          const imageMenu = (yield* Queue.take(menus)).input;
          assert.isUndefined(imageMenu.frame);
          const copyImage = imageMenu.template.find((item) => item.label === "Copy Image");
          const copyLink = imageMenu.template.find((item) => item.label === "Copy Link");
          assert.isDefined(copyImage?.click);
          assert.isDefined(copyLink?.click);
          copyImage.click({} as Electron.MenuItem, undefined, {} as Electron.KeyboardEvent);
          copyLink.click({} as Electron.MenuItem, undefined, {} as Electron.KeyboardEvent);
          assert.deepEqual(contents.copyImageAt.mock.calls, [[12, 34]]);
          assert.equal(copiedTexts.at(-1), "https://example.com/image.png");

          contents.isDestroyed.mockReturnValue(true);
          correction.click({} as Electron.MenuItem, undefined, {} as Electron.KeyboardEvent);
          copyImage.click({} as Electron.MenuItem, undefined, {} as Electron.KeyboardEvent);
          assert.equal(contents.replaceMisspelling.mock.calls.length, 1);
          assert.equal(contents.copyImageAt.mock.calls.length, 1);
          assert.equal(yield* Queue.size(menus), 0);
        }
      }).pipe(Effect.provide(layer));
    }),
  );

  it.effect("blocks only repeated Cmd+W input before it reaches the native window menu", () =>
    Effect.gen(function* () {
      const fakeWindow = makeFakeBrowserWindow();
      const createCount = yield* Ref.make(0);
      const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());

      const layer = makeTestLayer({
        window: fakeWindow.window,
        createCount,
        mainWindow,
      });

      yield* Effect.gen(function* () {
        const desktopWindow = yield* DesktopWindow.DesktopWindow;
        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));

        const beforeInput = fakeWindow.webContentsListeners.get("before-input-event");

        if (!beforeInput) {
          return yield* Effect.die("before-input-event listener was not registered");
        }

        let prevented = false;
        const event = { preventDefault: () => (prevented = true) };

        const input = {
          type: "keyDown",
          isAutoRepeat: true,
          key: "W",
          meta: true,
          control: false,
          alt: false,
          shift: false,
        };

        beforeInput(event, input);
        assert.isTrue(prevented);

        prevented = false;
        beforeInput(event, { ...input, isAutoRepeat: false });
        assert.isFalse(prevented);

        prevented = false;
        beforeInput(event, { ...input, meta: false });
        assert.isFalse(prevented);
      }).pipe(Effect.provide(layer));
    }),
  );

  // Chromium hands the main window's zoom level down to embedded preview
  // guests, so every app zoom has to put the preview browser back at its own
  // zoom or zooming the UI drags the previewed page with it.
  it.effect("restores the preview browser's own zoom after zooming the app", () =>
    Effect.gen(function* () {
      const fakeWindow = makeFakeBrowserWindow();
      const createCount = yield* Ref.make(0);
      const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
      const previewZoomReapplies: number[] = [];

      const layer = makeTestLayer({
        window: fakeWindow.window,
        createCount,
        mainWindow,
        previewZoomReapplies,
      });

      yield* Effect.gen(function* () {
        const desktopWindow = yield* DesktopWindow.DesktopWindow;
        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));

        yield* desktopWindow.zoomMain("out");
        yield* desktopWindow.zoomMain("out");
        yield* desktopWindow.zoomMain("in");
        yield* desktopWindow.zoomMain("reset");

        assert.deepEqual(
          fakeWindow.setZoomLevel.mock.calls.map(([level]) => level),
          [-0.5, -1, -0.5, 0],
        );
        // Recorded after the window level moved, so the preview is put back at
        // its own zoom on every step rather than left on the inherited one.
        assert.deepEqual(previewZoomReapplies, [-0.5, -1, -0.5, 0]);
      }).pipe(Effect.provide(layer));
    }),
  );

  it.effect("publishes native macOS fullscreen changes to the renderer", () =>
    Effect.gen(function* () {
      const fakeWindow = makeFakeBrowserWindow();
      const createCount = yield* Ref.make(0);
      const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());

      const layer = makeTestLayer({
        window: fakeWindow.window,
        createCount,
        mainWindow,
      });

      yield* Effect.gen(function* () {
        const desktopWindow = yield* DesktopWindow.DesktopWindow;
        yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));

        const enterFullscreen = fakeWindow.windowListeners.get("enter-full-screen");
        const leaveFullscreen = fakeWindow.windowListeners.get("leave-full-screen");

        if (!enterFullscreen || !leaveFullscreen) {
          return yield* Effect.die("fullscreen listeners were not registered");
        }

        enterFullscreen();
        leaveFullscreen();
        assert.deepEqual(fakeWindow.send.mock.calls, [
          [WINDOW_FULLSCREEN_STATE_CHANNEL, true],
          [WINDOW_FULLSCREEN_STATE_CHANNEL, false],
        ]);
      }).pipe(Effect.provide(layer));
    }),
  );
});

vi.mock("electron", async (importOriginal) => ({
  ...(await importOriginal<typeof import("electron")>()),
  session: {
    fromPartition: vi.fn(() => ({
      getUserAgent: vi.fn(() => "Mozilla/5.0 Electron/41.5.0 t3code/1.2.3"),
      setPermissionRequestHandler: vi.fn(),
      setUserAgent: vi.fn(),
    })),
  },
  screen: {
    getAllDisplays: vi.fn(() => [
      {
        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
      },
    ]),
  },
}));