Skip to content

The agent that grows with you

28.2 KB
Raw Blame
// @vitest-environment jsdom
import { act, type ReactNode } from "react";
import { createRoot, type Root } from "react-dom/client";
import { MemoryRouter } from "react-router";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {
  PTY_RECONNECT_MAX_ATTEMPTS,
  PTY_RECONNECT_MAX_MS,
  PTY_TICKET_TIMEOUT_MS,
} from "@/lib/pty-reconnect";

class FakeFitAddon {
  fit() {}
}

const webglInstances: FakeWebglAddon[] = [];

class FakeWebglAddon {
  disposed = false;
  onContextLoss() {
    return { dispose() {} };
  }
  dispose() {
    this.disposed = true;
  }
  constructor() {
    webglInstances.push(this);
  }
}

class FakeTerminal {
  options: Record<string, unknown>;
  rows = 24;
  cols = 80;
  parser = {
    registerOscHandler: vi.fn(),
  };
  unicode = { activeVersion: "" };

  constructor(options: Record<string, unknown>) {
    this.options = options;
  }

  attachCustomKeyEventHandler() {
    return true;
  }

  attachCustomWheelEventHandler() {
    return true;
  }

  clearSelection() {}

  clearTextureAtlas() {}

  dispose() {}

  focus() {}

  getSelection() {
    return "";
  }

  loadAddon() {}

  onData() {
    return { dispose() {} };
  }

  onResize() {
    return { dispose() {} };
  }

  onScroll() {
    return { dispose() {} };
  }

  get buffer() {
    // Minimal active-buffer surface for the resume follow-scroll pin
    // (isViewportPinnedToBottom reads viewportY/baseY).
    return { active: { baseY: 0, viewportY: 0 } };
  }

  scrollToBottom() {}

  open() {}

  paste() {}

  refresh() {}

  write() {}
}

const maybeReloadForLoopbackWsAuthFailure = vi.fn(() => false);
const apiMocks = vi.hoisted(() => ({
  buildWsUrl: vi.fn(async () => "ws://localhost/api/pty?channel=chat-1"),
}));
const uploadChatImage = vi.hoisted(() =>
  vi.fn(async () => ({ path: "/tmp/pasted.png" })),
);

vi.mock("@/lib/chatImagePaste", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@/lib/chatImagePaste")>()),
  uploadChatImage,
}));

vi.mock("@xterm/addon-fit", () => ({ FitAddon: FakeFitAddon }));
vi.mock("@xterm/addon-unicode11", () => ({ Unicode11Addon: class {} }));
vi.mock("@xterm/addon-web-links", () => ({ WebLinksAddon: class {} }));
vi.mock("@xterm/addon-webgl", () => ({ WebglAddon: FakeWebglAddon }));
vi.mock("@xterm/xterm", () => ({ Terminal: FakeTerminal }));
vi.mock("@/components/ChatSidebar", () => ({
  ChatSidebar: () => null,
}));
vi.mock("@/components/ChatSessionList", () => ({
  ChatSessionList: () => null,
}));
vi.mock("@/components/Backdrop", () => ({ Backdrop: () => null }));
vi.mock("@/plugins", () => ({
  PluginSlot: () => null,
}));
vi.mock("@/contexts/usePageHeader", () => ({
  usePageHeader: () => ({ setEnd: vi.fn(), setTitle: vi.fn() }),
}));
vi.mock("@/contexts/useProfileScope", () => ({
  useProfileScope: () => ({ profile: "" }),
}));
vi.mock("@/themes", () => ({
  useTheme: () => ({ theme: { terminalBackground: "#000000" } }),
}));
vi.mock("@/i18n", () => ({
  useI18n: () => ({
    t: {
      app: {
        closeModelTools: "Close model tools",
        modelToolsSheetSubtitle: "Tools",
        modelToolsSheetTitle: "Model",
      },
    },
  }),
}));
vi.mock("@/lib/dashboard-auth-reload", () => ({
  maybeReloadForLoopbackWsAuthFailure,
}));
vi.mock("@/lib/api", () => ({
  api: apiMocks,
  buildWsUrl: apiMocks.buildWsUrl,
}));

class FakeWebSocket {
  static instances: FakeWebSocket[] = [];
  static OPEN = 1;

  binaryType = "blob";
  onclose: ((event: CloseEventLike) => void) | null = null;
  onmessage: ((event: { data: ArrayBuffer | string }) => void) | null = null;
  onopen: (() => void) | null = null;
  readyState = FakeWebSocket.OPEN;
  url: string;

  constructor(url: string) {
    this.url = url;
    FakeWebSocket.instances.push(this);
  }

  close() {
    this.readyState = 3;
  }

  send = vi.fn();
}

type CloseEventLike = {
  code: number;
  reason: string;
  wasClean: boolean;
};

let container: HTMLDivElement;
let root: Root;

// jsdom runs without an origin here (per-file @vitest-environment jsdom on a
// node-default config), so localStorage is undefined. Stub it so components
// that persist UI state (side panel collapse) can be exercised.
const localStorageMock = (() => {
  let store: Record<string, string> = {};
  return {
    getItem: (key: string) => store[key] ?? null,
    setItem: (key: string, value: string) => {
      store[key] = String(value);
    },
    removeItem: (key: string) => {
      delete store[key];
    },
    clear: () => {
      store = {};
    },
  };
})();

// React only routes updates through act() when this flag is set; without it
// the isActive re-renders in the keyboard-inset gate test warn.
(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT =
  true;

async function render(ui: ReactNode) {
  container = document.createElement("div");
  document.body.append(container);
  root = createRoot(container);
  await act(async () => root.render(ui));
}

beforeEach(() => {
  FakeWebSocket.instances = [];
  webglInstances.length = 0;
  maybeReloadForLoopbackWsAuthFailure.mockClear();
  apiMocks.buildWsUrl.mockReset();
  apiMocks.buildWsUrl.mockResolvedValue("ws://localhost/api/pty?channel=chat-1");
  vi.stubGlobal("WebSocket", FakeWebSocket);
  vi.stubGlobal(
    "ResizeObserver",
    class {
      disconnect() {}
      observe() {}
      unobserve() {}
    },
  );
  vi.stubGlobal("requestAnimationFrame", (cb: FrameRequestCallback) => {
    cb(0);
    return 1;
  });
  vi.stubGlobal("cancelAnimationFrame", () => {});
  vi.stubGlobal("matchMedia", () => ({
    addEventListener() {},
    matches: false,
    media: "",
    removeEventListener() {},
  }));
  vi.stubGlobal("crypto", {
    getRandomValues: (values: Uint8Array) => {
      values.fill(7);
      return values;
    },
    randomUUID: () => "chat-test-id",
  });

  Object.defineProperty(window, "visualViewport", {
    configurable: true,
    value: { addEventListener() {}, removeEventListener() {}, width: 1280 },
  });
  Object.defineProperty(window, "__HERMES_SESSION_TOKEN__", {
    configurable: true,
    value: "stale-token",
    writable: true,
  });
  Object.defineProperty(window, "__HERMES_AUTH_REQUIRED__", {
    configurable: true,
    value: false,
    writable: true,
  });
  Object.defineProperty(window.navigator, "clipboard", {
    configurable: true,
    value: {
      readText: vi.fn(async () => ""),
      writeText: vi.fn(async () => {}),
    },
  });
  sessionStorage.clear();
  vi.stubGlobal("localStorage", localStorageMock);
  localStorageMock.clear();
});

afterEach(async () => {
  await act(async () => root?.unmount());
  container?.remove();
  vi.unstubAllGlobals();
});

describe("ChatPage", () => {
  it("sends a PTY keepalive frame every 20 seconds while the socket is open", async () => {
    vi.useFakeTimers();
    try {
      const { default: ChatPage } = await import("./ChatPage");
      await render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive />
        </MemoryRouter>,
      );
      await act(async () => {
        await Promise.resolve();
      });
      expect(FakeWebSocket.instances).toHaveLength(1);

      const socket = FakeWebSocket.instances[0];
      await act(async () => socket.onopen?.());
      socket.send.mockClear();
      await act(async () => {
        await vi.advanceTimersByTimeAsync(20_000);
      });

      expect(socket.send).toHaveBeenCalledWith("\x1b[RESIZE:80;24]");
    } finally {
      vi.useRealTimers();
    }
  });

  it("defers a reconnect while the chat tab is inactive", async () => {
    vi.useFakeTimers();
    try {
      const { default: ChatPage } = await import("./ChatPage");
      await render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive />
        </MemoryRouter>,
      );
      await act(async () => {
        await Promise.resolve();
      });
      const socket = FakeWebSocket.instances[0];
      await act(async () => {
        socket.onclose?.({ code: 1001, reason: "", wasClean: true });
        root.render(
          <MemoryRouter initialEntries={["/chat"]}>
            <ChatPage isActive={false} />
          </MemoryRouter>,
        );
      });
      await act(async () => {
        await vi.advanceTimersByTimeAsync(1_000);
      });

      expect(FakeWebSocket.instances).toHaveLength(1);
    } finally {
      vi.useRealTimers();
    }
  });

  // #52471: a native/DOM paste (context-menu paste, middle-click, or any
  // Ctrl+V route that bypasses the keydown interception) must deliver its
  // text through term.paste() exactly once — never through the browser's
  // default insertion into xterm's hidden textarea, which leaves a stale
  // value there and duplicates the next typed character.
  async function renderChat() {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));
    return container.querySelector(".hermes-chat-xterm-host")!;
  }

  function textPasteEvent(text: string) {
    const paste = new Event("paste", { bubbles: true, cancelable: true });
    Object.defineProperty(paste, "clipboardData", {
      value: {
        files: [],
        getData: (type: string) => (type === "text/plain" ? text : ""),
        items: [],
      },
    });
    return paste;
  }

  it("delivers a native text paste through term.paste exactly once (#52471)", async () => {
    const host = await renderChat();
    const pasteSpy = vi.spyOn(FakeTerminal.prototype, "paste");
    try {
      const paste = textPasteEvent("abc");
      await act(async () => {
        host.dispatchEvent(paste);
      });
      // Exactly one delivery, via the terminal paste path that resets the
      // hidden textarea — a paste of "abc" yields "abc", never a stale-value
      // double send of the last character on the next keystroke.
      expect(pasteSpy).toHaveBeenCalledTimes(1);
      expect(pasteSpy).toHaveBeenCalledWith("abc");
      expect(paste.defaultPrevented).toBe(true);
      expect(uploadChatImage).not.toHaveBeenCalled();
    } finally {
      pasteSpy.mockRestore();
    }
  });

  it("keeps the image-paste route working: image pastes upload instead of pasting text", async () => {
    const host = await renderChat();
    const pasteSpy = vi.spyOn(FakeTerminal.prototype, "paste");
    try {
      const paste = new Event("paste", { bubbles: true, cancelable: true });
      const file = new File([new Uint8Array([1, 2, 3])], "shot.png", {
        type: "image/png",
      });
      Object.defineProperty(paste, "clipboardData", {
        value: {
          files: [file],
          getData: () => "",
          items: [{ getAsFile: () => file, kind: "file", type: "image/png" }],
        },
      });
      await act(async () => {
        host.dispatchEvent(paste);
      });
      await vi.waitFor(() => expect(uploadChatImage).toHaveBeenCalledTimes(1));
      expect(pasteSpy).not.toHaveBeenCalled();
      expect(paste.defaultPrevented).toBe(true);
    } finally {
      pasteSpy.mockRestore();
    }
  });

  it("reconnects on tab return after a hidden-tab close even when a stale upload banner is showing", async () => {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));
    const socket = FakeWebSocket.instances[0];
    await act(async () => socket.onopen?.());

    // A failed image paste leaves a non-rejection banner behind.
    uploadChatImage.mockRejectedValueOnce(new Error("disk full"));
    const host = container.querySelector(".hermes-chat-xterm-host");
    expect(host).not.toBeNull();
    const paste = new Event("paste", { bubbles: true, cancelable: true });
    const file = new File([new Uint8Array([1, 2, 3])], "shot.png", { type: "image/png" });
    Object.defineProperty(paste, "clipboardData", {
      value: {
        files: [file],
        items: [{ getAsFile: () => file, kind: "file", type: "image/png" }],
      },
    });
    await act(async () => {
      host!.dispatchEvent(paste);
    });
    await vi.waitFor(() =>
      expect(container.textContent).toContain("Image upload failed"),
    );

    // The socket dies while the tab is hidden: the reconnect is deferred.
    Object.defineProperty(document, "visibilityState", {
      configurable: true,
      get: () => "hidden",
    });
    await act(async () => {
      socket.onclose?.({ code: 1001, reason: "", wasClean: true });
    });
    expect(FakeWebSocket.instances).toHaveLength(1);

    // Coming back must start the deferred reconnect despite the old banner.
    Object.defineProperty(document, "visibilityState", {
      configurable: true,
      get: () => "visible",
    });
    await act(async () => {
      document.dispatchEvent(new Event("visibilitychange"));
    });
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(2));
  });

  it("treats loopback 4401 closes as stale-token reload candidates", async () => {
    const { default: ChatPage } = await import("./ChatPage");

    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );

    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    FakeWebSocket.instances[0].onclose?.({
      code: 4401,
      reason: "auth: token_mismatch",
      wasClean: true,
    });

    expect(maybeReloadForLoopbackWsAuthFailure).toHaveBeenCalledWith(4401);
  });

  it("offers a Reload button for an expired login when auto-reload is spent", async () => {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    await act(async () => {
      FakeWebSocket.instances[0].onclose?.({ code: 4401, reason: "auth: bad-token", wasClean: true });
    });

    const labels = Array.from(container.querySelectorAll("button")).map((b) => b.textContent?.trim());
    expect(labels).toContain("Reload page");
  });

  it("renders Start new session after the server could not start the chat (1011)", async () => {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    await act(async () => {
      FakeWebSocket.instances[0].onclose?.({ code: 1011, reason: "", wasClean: true });
    });

    const labels = Array.from(container.querySelectorAll("button")).map((b) => b.textContent?.trim());
    expect(labels).toContain("Start new session");
  });

  it("offers Start new session and Open logs when the agent process ended", async () => {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    await act(async () => {
      FakeWebSocket.instances[0].onclose?.({ code: 4410, reason: "", wasClean: true });
    });

    const labels = Array.from(container.querySelectorAll("button")).map((b) => b.textContent?.trim());
    expect(labels).toContain("Start new session");
    expect(labels).toContain("Open logs");
  });

  it("stops retrying after the ladder is spent and offers Check server status", async () => {
    vi.useFakeTimers();
    try {
      const { default: ChatPage } = await import("./ChatPage");
      await render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive />
        </MemoryRouter>,
      );
      await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

      // Drop the socket abnormally; walk every scheduled retry to failure.
      for (let attempt = 0; attempt <= PTY_RECONNECT_MAX_ATTEMPTS; attempt += 1) {
        const sockets = FakeWebSocket.instances.length;
        await act(async () => {
          FakeWebSocket.instances[sockets - 1].onclose?.({ code: 1006, reason: "", wasClean: false });
        });
        await act(async () => {
          await vi.advanceTimersByTimeAsync(PTY_RECONNECT_MAX_MS + 100);
        });
      }

      const labels = Array.from(container.querySelectorAll("button")).map((b) => b.textContent?.trim());
      expect(labels).toContain("Reconnect now");
      expect(labels).toContain("Check server status");
    } finally {
      vi.useRealTimers();
    }
  });

  it("redials after a clean 1012 service-restart close (#95951)", async () => {
    const { default: ChatPage } = await import("./ChatPage");

    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    // 1012 is a CLEAN close (wasClean=true) that is neither 1001 nor 1006 —
    // the old guard fell through to "[session ended]" with no retry. The
    // server is coming back, so the pane must redial: the 250ms first-attempt
    // backoff re-runs the connect effect and opens a fresh socket.
    FakeWebSocket.instances[0].onclose?.({
      code: 1012,
      reason: "",
      wasClean: true,
    });

    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(2), {
      timeout: 3000,
    });
  });

  it("attaches visualViewport keyboard-inset listeners only while the chat tab is active", async () => {
    // NS-434 follow-up: ChatPage stays mounted (hidden) on every dashboard
    // route. The keyboard-inset/scroll-pin listeners must only be live while
    // /chat is the active tab, or the scroll pin fires when a soft keyboard
    // opens on Settings etc.
    const addEventListener = vi.fn();
    const removeEventListener = vi.fn();
    Object.defineProperty(window, "visualViewport", {
      configurable: true,
      value: { addEventListener, removeEventListener, width: 1280 },
    });

    const { default: ChatPage } = await import("./ChatPage");

    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive={false} />
      </MemoryRouter>,
    );
    expect(addEventListener).not.toHaveBeenCalled();

    await act(async () =>
      root.render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive />
        </MemoryRouter>,
      ),
    );
    expect(addEventListener.mock.calls.map((c) => c[0]).sort()).toEqual([
      "resize",
      "scroll",
    ]);
    expect(removeEventListener).not.toHaveBeenCalled();

    await act(async () =>
      root.render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive={false} />
        </MemoryRouter>,
      ),
    );
    expect(removeEventListener.mock.calls.map((c) => c[0]).sort()).toEqual([
      "resize",
      "scroll",
    ]);
  });
});

describe("ChatPage side panel collapse", () => {
  async function renderChat() {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
  }

  it("collapses the desktop side panel and persists the choice", async () => {
    localStorage.clear();
    await renderChat();
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    const collapseButton = container.querySelector(
      '[aria-label="Collapse chat side panel"]',
    );
    expect(collapseButton).not.toBeNull();

    await act(async () => {
      collapseButton!.dispatchEvent(
        new MouseEvent("click", { bubbles: true }),
      );
    });

    expect(localStorage.getItem("hermes-chat-panel-collapsed")).toBe("1");
    expect(
      container.querySelector('[aria-label="Collapse chat side panel"]'),
    ).toBeNull();
    expect(
      container.querySelector('[aria-label="Show chat side panel"]'),
    ).not.toBeNull();

    // Reopening restores the panel and clears the persisted flag.
    await act(async () => {
      container
        .querySelector('[aria-label="Show chat side panel"]')!
        .dispatchEvent(new MouseEvent("click", { bubbles: true }));
    });

    expect(localStorage.getItem("hermes-chat-panel-collapsed")).toBe("0");
    expect(
      container.querySelector('[aria-label="Collapse chat side panel"]'),
    ).not.toBeNull();
  });
});

// The gated-mode ticket request runs before any socket exists, so a rejection
// or a hang emits no `close` event and never arms PTY_CONNECTING_TIMEOUT_MS
// (that timer is set after `new WebSocket`). Without its own deadline the tab
// strands on "connecting" with no retry. Mirrors the ChatSidebar events-feed
// coverage in src/components/ChatSidebar.test.tsx.
describe("ChatPage bundled font swap-in", () => {
  it("redraws the terminal with the bundled font once it finishes loading", async () => {
    let releaseFont!: () => void;
    const fontGate = new Promise<void>((resolve) => {
      releaseFont = resolve;
    });
    Object.defineProperty(document, "fonts", {
      configurable: true,
      value: {
        check: () => false,
        load: async () => {
          await fontGate;
          return [{}];
        },
      },
    });
    const clearAtlas = vi.spyOn(FakeTerminal.prototype, "clearTextureAtlas");
    try {
      const { default: ChatPage } = await import("./ChatPage");
      await render(
        <MemoryRouter initialEntries={["/chat"]}>
          <ChatPage isActive />
        </MemoryRouter>,
      );
      expect(clearAtlas).not.toHaveBeenCalled();

      await act(async () => {
        releaseFont();
        await fontGate;
        await new Promise((resolve) => setTimeout(resolve, 0));
      });

      expect(clearAtlas).toHaveBeenCalledTimes(1);
    } finally {
      clearAtlas.mockRestore();
      delete (document as { fonts?: unknown }).fonts;
    }
  });
});

describe("ChatPage PTY ticket connect deadline", () => {
  beforeEach(() => {
    vi.useFakeTimers();
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  async function renderChat() {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
  }

  /** Advance timers and flush the async connect that fires on the tick. */
  async function advance(ms: number) {
    await act(async () => {
      await vi.advanceTimersByTimeAsync(ms);
    });
  }

  it("retries when the ticket request rejects", async () => {
    apiMocks.buildWsUrl.mockRejectedValueOnce(
      new Error("ticket endpoint unavailable"),
    );

    await renderChat();
    await advance(0);
    expect(FakeWebSocket.instances).toHaveLength(0);

    // First backoff step is 250ms; the retry must mint a fresh ticket.
    await advance(250);
    expect(apiMocks.buildWsUrl).toHaveBeenCalledTimes(2);
    expect(FakeWebSocket.instances).toHaveLength(1);
  });

  it("times out a stalled ticket request and retries", async () => {
    let resolveStalledRequest!: (url: string) => void;
    apiMocks.buildWsUrl.mockImplementationOnce(
      () =>
        new Promise<string>((resolve) => {
          resolveStalledRequest = resolve;
        }),
    );

    await renderChat();
    await advance(0);
    expect(FakeWebSocket.instances).toHaveLength(0);

    await advance(PTY_TICKET_TIMEOUT_MS);
    expect(FakeWebSocket.instances).toHaveLength(0);

    // A late ticket from the timed-out attempt must not open a socket behind
    // the replacement the deadline scheduled.
    await act(async () => {
      resolveStalledRequest("ws://localhost/api/pty?channel=stale");
      await Promise.resolve();
    });
    expect(FakeWebSocket.instances).toHaveLength(0);

    await advance(250);
    expect(FakeWebSocket.instances).toHaveLength(1);
    expect(FakeWebSocket.instances[0].url).not.toContain("channel=stale");
  });

  it("leaves a settled ticket's socket to the CONNECTING timer", async () => {
    await renderChat();
    await advance(0);
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    // NS-591 regression: once the socket exists the ticket deadline is
    // disarmed, so PTY_CONNECTING_TIMEOUT_MS stays the only thing that may
    // force-close a wedged handshake — the two must not both fire.
    await advance(PTY_TICKET_TIMEOUT_MS);
    expect(apiMocks.buildWsUrl).toHaveBeenCalledTimes(1);
  });
});

// xterm WebGL renderer gating (#18773 / #45520 / #58685): the addon must only
// load when the host can actually use it (wide layout, non-Safari, hardware GL)
// and must be dropped when shaped-script text arrives.
describe("ChatPage WebGL renderer gating", () => {
  const CHROME_UA =
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
  const SAFARI_UA =
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15";

  /** Stub the probe's canvas context per test. */
  function stubCanvasContext(
    getContext: () => WebGLRenderingContext | null,
  ): void {
    vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockImplementation(
      getContext as never,
    );
  }

  function hardwareGl(): WebGLRenderingContext | null {
    return {
      getExtension: (name: string) => {
        if (name === "WEBGL_debug_renderer_info") {
          return { UNMASKED_RENDERER_WEBGL: 0x9246 };
        }
        if (name === "WEBGL_lose_context") {
          return { loseContext: () => undefined };
        }
        return null;
      },
      getParameter: () => "Apple M2",
    } as unknown as WebGLRenderingContext;
  }

  async function renderChat() {
    const { default: ChatPage } = await import("./ChatPage");
    await render(
      <MemoryRouter initialEntries={["/chat"]}>
        <ChatPage isActive />
      </MemoryRouter>,
    );
    await act(async () => {
      await Promise.resolve();
    });
  }

  afterEach(() => {
    vi.restoreAllMocks();
  });

  it("loads the WebGL addon on a wide hardware-GL Chrome host", async () => {
    Object.defineProperty(window.navigator, "userAgent", {
      configurable: true,
      value: CHROME_UA,
      writable: true,
    });
    stubCanvasContext(hardwareGl);

    await renderChat();
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    expect(webglInstances).toHaveLength(1);
    expect(webglInstances[0].disposed).toBe(false);
  });

  it("skips the WebGL addon on Safari (#18773)", async () => {
    Object.defineProperty(window.navigator, "userAgent", {
      configurable: true,
      value: SAFARI_UA,
      writable: true,
    });
    stubCanvasContext(hardwareGl);

    await renderChat();
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    expect(webglInstances).toHaveLength(0);
  });

  it("skips the WebGL addon when no WebGL context exists (#45520)", async () => {
    Object.defineProperty(window.navigator, "userAgent", {
      configurable: true,
      value: CHROME_UA,
      writable: true,
    });
    stubCanvasContext(() => null);

    await renderChat();
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    expect(webglInstances).toHaveLength(0);
  });

  it("skips the WebGL addon on a software renderer like llvmpipe (#45520)", async () => {
    Object.defineProperty(window.navigator, "userAgent", {
      configurable: true,
      value: CHROME_UA,
      writable: true,
    });
    stubCanvasContext(() =>
      ({
        ...hardwareGl(),
        getParameter: () => "llvmpipe (LLVM 21.1.8, 256 bits)",
      }) as unknown as WebGLRenderingContext,
    );

    await renderChat();
    await vi.waitFor(() => expect(FakeWebSocket.instances).toHaveLength(1));

    expect(webglInstances).toHaveLength(0);
  });

  it("disposes the WebGL addon when Bengali text arrives (#58685)", async () => {
    Object.defineProperty(window.navigator, "userAgent", {
      configurable: true,
      value: CHROME_UA,
      writable: true,
    });
    stubCanvasContext(hardwareGl);

    await renderChat();
    const socket = FakeWebSocket.instances[0];
    await act(async () => socket.onopen?.());
    expect(webglInstances).toHaveLength(1);
    expect(webglInstances[0].disposed).toBe(false);

    await act(async () => {
      socket.onmessage?.({ data: "যুক্তাক্ষর প্রযুক্তি" });
    });

    expect(webglInstances[0].disposed).toBe(true);
  });
});