Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
/** @vitest-environment jsdom */
import { act, cleanup, fireEvent, render } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { MemoryRouter } from 'react-router-dom';
import { createRef, type ComponentProps } from 'react';
vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
vi.mock('../../context/ApiContext', () => ({ useApi: () => ({}) }));
vi.mock('../../context/ToastContext', () => ({ useToast: () => ({ showToast: vi.fn() }) }));
vi.mock('../../context/InstanceAuthorizationContext', () => ({
useInstanceAuthorization: () => ({
capabilities: { can_chat: true, can_manage_instance: false, can_use_show_pages: false, can_use_vault_secrets: false },
}),
}));
vi.mock('../../context/WindowManagerContext', () => ({
useWindowManager: () => ({ focusedId: null, focusCanvas: vi.fn() }),
}));
vi.mock('../../lib/useIsDesktop', () => ({ isDesktopViewport: () => false, useIsDesktop: () => false }));
// The transcript does not render the composer's browser-only Lexical stack.
vi.mock('./Composer', () => ({ Composer: () => null }));
import { Transcript } from './ChatPage';
import type { WorkbenchMessage, WorkbenchSession } from '../../context/ApiContext';
type Props = ComponentProps<typeof Transcript>;
const messages = (first: number, count: number): WorkbenchMessage[] =>
Array.from({ length: count }, (_, index) => ({
id: `msg-${first + index}`,
session_id: 'session-1',
platform: 'avibe',
author: 'user',
type: 'user',
text: `Message ${first + index}`,
content: {},
metadata: {},
created_at: new Date(Date.UTC(2026, 8, 1, 0, 0, first + index)).toISOString(),
}) as WorkbenchMessage);
const pendingPage = () => {
let land!: (ok: boolean) => void;
const promise = new Promise<boolean>((resolve) => { land = resolve; });
return { promise, land };
};
let nextFrameId = 1;
const frames = new Map<number, FrameRequestCallback>();
const flushFrames = () => {
const queued = [...frames.values()];
frames.clear();
queued.forEach((callback) => callback(0));
};
class TestResizeObserver {
static live = new Set<TestResizeObserver>();
constructor(private callback: ResizeObserverCallback) { TestResizeObserver.live.add(this); }
observe() {}
unobserve() {}
disconnect() { TestResizeObserver.live.delete(this); }
static resize() { for (const observer of TestResizeObserver.live) observer.callback([], observer as unknown as ResizeObserver); }
}
const renderTranscript = (over: Partial<Props> = {}) => {
const props: Props = {
messages: messages(301, 50),
session: { id: 'session-1', title: 'Session', agent_name: null, archived_at: null } as WorkbenchSession,
agentDisplayName: null,
working: false,
hasOlder: true,
loadingOlder: false,
onLoadOlder: vi.fn().mockResolvedValue(true),
needsLatestReload: false,
onReloadLatest: vi.fn().mockResolvedValue(true),
jumpTarget: null,
onJumpHandled: vi.fn(),
highlightedId: null,
messageFontSize: 14,
onQuickReply: vi.fn(),
provisionRequestsByMessage: new Map(),
onVaultRequestResolved: vi.fn(),
onQuoteSelection: vi.fn(),
onAskInNewSession: vi.fn(),
readOnly: false,
followingTailRef: createRef<boolean>() as React.MutableRefObject<boolean>,
...over,
};
const view = render(<MemoryRouter><Transcript {...props} /></MemoryRouter>);
const scroller = view.getByTestId('chat-transcript');
const geometry = { extraAbove: 0 };
let scrollTop = 0;
// jsdom has no layout, so geometry comes from the committed content column's
// direct children: the head slot and the rows, which pickScrollAnchor walks too.
// Walk siblings instead of querying the subtree. The anchor search reads one
// rect per row above the viewport, and a subtree query per rect made each
// scroll cost (rows above) x (whole DOM): seconds over 300 rows on CI.
const column = () => scroller.firstElementChild!;
const rowsFrom = (node: Element | null) => {
let count = 0;
for (; node; node = node.previousElementSibling) if ((node as HTMLElement).dataset.messageId !== undefined) count += 1;
return count;
};
// The loading slot or failed-load retry above the rows, plus the column gap.
const loadingSlotHeight = () => {
for (const child of column().children) {
if ((child as HTMLElement).dataset.messageId !== undefined) return 0;
if (child.matches('[role="status"], button') && child.classList.contains('h-8')) return 44;
}
return 0;
};
Object.defineProperties(scroller, {
clientHeight: { configurable: true, get: () => 800 },
scrollHeight: { configurable: true, get: () => rowsFrom(column().lastElementChild) * 112 + 40 + loadingSlotHeight() + geometry.extraAbove },
scrollTop: {
configurable: true,
get: () => scrollTop,
set: (value: number) => { scrollTop = Math.max(0, Math.min(value, scroller.scrollHeight - scroller.clientHeight)); },
},
});
scroller.getBoundingClientRect = () => ({ top: 10, bottom: 810, height: 800 }) as DOMRect;
// A row's position counts the rows before it and the transient loading slot.
vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
if (this.dataset.messageId === undefined) return { top: 0, bottom: 0, height: 0 } as DOMRect;
const index = rowsFrom(this.previousElementSibling);
const top = 30 + index * 112 + loadingSlotHeight() + (index > 0 ? geometry.extraAbove : 0) - scrollTop;
return { top, bottom: top + 100, height: 100 } as DOMRect;
});
act(flushFrames);
const rerender = (next: Partial<Props>) => {
Object.assign(props, next);
view.rerender(<MemoryRouter><Transcript {...props} /></MemoryRouter>);
};
const scrollTo = (top: number) => {
fireEvent.pointerDown(scroller, { pointerType: 'mouse' });
scroller.scrollTop = top;
fireEvent.scroll(scroller);
};
return { ...view, scroller, geometry, props, rerender, scrollTo };
};
describe('transcript older-page loading', () => {
beforeEach(() => {
vi.stubGlobal('CSS', { escape: (value: string) => value });
TestResizeObserver.live.clear();
vi.stubGlobal('ResizeObserver', TestResizeObserver);
vi.stubGlobal('IntersectionObserver', class { observe() {} disconnect() {} unobserve() {} });
nextFrameId = 1;
frames.clear();
vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
const id = nextFrameId++;
frames.set(id, callback);
return id;
});
vi.stubGlobal('cancelAnimationFrame', (id: number) => frames.delete(id));
});
afterEach(() => {
cleanup();
vi.restoreAllMocks();
vi.unstubAllGlobals();
});
it('requires fresh upward input for each page, even when a page adds no visible rows', async () => {
const now = vi.spyOn(performance, 'now').mockReturnValue(0);
const page = pendingPage();
const onLoadOlder = vi.fn().mockReturnValueOnce(page.promise).mockResolvedValue(true);
const { scroller, scrollTo, rerender } = renderTranscript({ onLoadOlder });
scrollTo(0);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
rerender({ loadingOlder: true });
fireEvent.wheel(scroller, { deltaY: -100 });
fireEvent.scroll(scroller);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => { rerender({ loadingOlder: false }); page.land(true); });
act(TestResizeObserver.resize);
fireEvent.scroll(scroller);
expect(scroller.scrollTop).toBe(0);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
now.mockReturnValue(300);
await act(async () => fireEvent.wheel(scroller, { deltaY: -100 }));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it.each([50, 300])('preserves the reader through a prepend with %i retained rows and no resize notification', async (count) => {
const page = pendingPage();
const onLoadOlder = vi.fn().mockReturnValueOnce(page.promise).mockReturnValue(new Promise(() => {}));
const { scroller, scrollTo, rerender, geometry } = renderTranscript({ messages: messages(301, count), onLoadOlder });
scrollTo(0);
const anchor = scroller.querySelector('[data-message-id="msg-301"]')!;
const before = anchor.getBoundingClientRect().top;
const height = scroller.scrollHeight;
rerender({ loadingOlder: true });
expect(anchor.getBoundingClientRect().top).toBe(before);
expect(scroller.scrollTop).toBe(44);
await act(async () => {
rerender({ messages: messages(251, Math.min(count + 50, 300)), loadingOlder: false });
page.land(true);
});
expect(anchor.getBoundingClientRect().top).toBe(before);
expect(scroller.scrollTop).toBe(50 * 112);
if (count === 300) expect(scroller.scrollHeight).toBe(height);
// A queued scroll from mounting/removing the spinner sees the restored DOM.
fireEvent.scroll(scroller);
rerender({ agentDisplayName: 'Renamed agent' });
expect(onLoadOlder).toHaveBeenCalledTimes(1);
geometry.extraAbove = 180;
act(TestResizeObserver.resize);
fireEvent.scroll(scroller);
expect(anchor.getBoundingClientRect().top).toBe(before);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
scrollTo(0);
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('allows another upward scroll inside the trigger band without a down-and-up detour', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scrollTo } = renderTranscript({ onLoadOlder });
await act(async () => scrollTo(110));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => scrollTo(100));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
const upwardInputs = {
wheel: (el: HTMLElement) => fireEvent.wheel(el, { deltaY: -100 }),
touch: (el: HTMLElement) => {
fireEvent.touchStart(el, { touches: [{ clientY: 100 }] });
fireEvent.touchMove(el, { touches: [{ clientY: 140 }] });
fireEvent.touchEnd(el);
},
keyboard: (el: HTMLElement) => fireEvent.keyDown(el, { key: 'PageUp' }),
};
it.each(Object.entries(upwardInputs))('accepts %s input at the hard top without a scroll event', async (_name, upward) => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller, rerender, props } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
act(TestResizeObserver.resize);
rerender({ agentDisplayName: 'Renamed agent' });
expect(scroller.scrollTop).toBe(0);
expect(onLoadOlder).not.toHaveBeenCalled();
await act(async () => upward(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
expect(props.followingTailRef.current).toBe(false);
});
it('consumes one touch drag across settled empty pages and momentum scrolls', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
fireEvent.touchStart(scroller, { touches: [{ clientY: 100 }] });
for (const clientY of [140, 180, 220]) {
await act(async () => fireEvent.touchMove(scroller, { touches: [{ clientY }] }));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
}
fireEvent.touchEnd(scroller);
fireEvent.scroll(scroller);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => upwardInputs.touch(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('keeps a wheel burst consumed through momentum and rearms after an idle gap', async () => {
const now = vi.spyOn(performance, 'now').mockReturnValue(0);
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
for (const timestamp of [0, 50, 150, 250]) {
now.mockReturnValue(timestamp);
await act(async () => upwardInputs.wheel(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
}
now.mockReturnValue(550);
await act(async () => upwardInputs.wheel(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('shares gesture consumption with scroll events inside the trigger band', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller, scrollTo } = renderTranscript({ onLoadOlder });
scrollTo(200);
fireEvent.touchStart(scroller, { touches: [{ clientY: 100 }] });
for (const top of [110, 90]) {
await act(async () => {
scroller.scrollTop = top;
fireEvent.scroll(scroller);
});
expect(onLoadOlder).toHaveBeenCalledTimes(1);
}
fireEvent.touchEnd(scroller);
await act(async () => {
scroller.scrollTop = 70;
fireEvent.scroll(scroller);
});
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => upwardInputs.touch(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('consumes input begun while a page is pending until the next gesture', async () => {
const first = pendingPage();
const onLoadOlder = vi.fn().mockReturnValueOnce(first.promise).mockResolvedValue(true);
const { scroller, scrollTo } = renderTranscript({ onLoadOlder });
scrollTo(0);
fireEvent.touchStart(scroller, { touches: [{ clientY: 100 }] });
fireEvent.touchMove(scroller, { touches: [{ clientY: 140 }] });
await act(async () => first.land(true));
await act(async () => fireEvent.touchMove(scroller, { touches: [{ clientY: 180 }] }));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
fireEvent.touchEnd(scroller);
await act(async () => upwardInputs.touch(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('is keyboard focusable and requires a fresh key press after an empty page', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
expect(scroller.tabIndex).toBe(0);
scroller.focus();
expect(document.activeElement).toBe(scroller);
await act(async () => upwardInputs.keyboard(scroller));
await act(async () => fireEvent.keyDown(scroller, { key: 'PageUp', repeat: true }));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => upwardInputs.keyboard(scroller));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it.each(Object.entries(upwardInputs))('lets a nested scroller own %s input until it can chain upward', async (_name, upward) => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
const panel = document.createElement('div');
panel.style.overflowY = 'auto';
Object.defineProperties(panel, { clientHeight: { value: 100 }, scrollHeight: { value: 500 } });
panel.scrollTop = 120;
const target = document.createElement('span');
panel.append(target);
scroller.append(panel);
await act(async () => upward(target));
expect(onLoadOlder).not.toHaveBeenCalled();
panel.scrollTop = 0;
panel.style.overscrollBehaviorY = 'contain';
await act(async () => upward(target));
expect(onLoadOlder).not.toHaveBeenCalled();
panel.style.overscrollBehaviorY = 'auto';
await act(async () => upward(target));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
});
it('does not interpret downward, pinch, or editing input as a request for history', () => {
const onLoadOlder = vi.fn();
const { scroller } = renderTranscript({ messages: messages(1, 1), onLoadOlder });
fireEvent.wheel(scroller, { deltaY: 100 });
fireEvent.keyDown(scroller, { key: 'PageDown' });
fireEvent.touchStart(scroller, { touches: [{ clientY: 100 }] });
fireEvent.touchMove(scroller, { touches: [{ clientY: 80 }] });
fireEvent.touchMove(scroller, { touches: [{ clientY: 140 }, { clientY: 160 }] });
const input = document.createElement('input');
scroller.append(input);
fireEvent.keyDown(input, { key: 'Home' });
expect(onLoadOlder).not.toHaveBeenCalled();
});
it('serializes multiple upward inputs until the active request settles', async () => {
const first = pendingPage();
const onLoadOlder = vi.fn().mockReturnValue(first.promise);
const { scroller, scrollTo } = renderTranscript({ onLoadOlder });
scrollTo(0);
for (const upward of Object.values(upwardInputs)) upward(scroller);
scrollTo(500);
scrollTo(0);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => first.land(true));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
});
it('stops when history is exhausted', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller, scrollTo, rerender } = renderTranscript({ onLoadOlder });
await act(async () => scrollTo(0));
rerender({ hasOlder: false });
for (const upward of Object.values(upwardInputs)) upward(scroller);
expect(onLoadOlder).toHaveBeenCalledTimes(1);
});
it('keeps a deep-link jump stable until the reader asks for more history', async () => {
const now = vi.spyOn(performance, 'now').mockReturnValue(0);
const onLoadOlder = vi.fn().mockResolvedValue(true);
const { scroller, scrollTo, rerender } = renderTranscript({ onLoadOlder, jumpTarget: 'missing-target' });
scrollTo(0);
fireEvent.wheel(scroller, { deltaY: -100 });
expect(onLoadOlder).not.toHaveBeenCalled();
act(flushFrames);
rerender({ jumpTarget: null });
expect(onLoadOlder).not.toHaveBeenCalled();
now.mockReturnValue(300);
await act(async () => fireEvent.wheel(scroller, { deltaY: -100 }));
expect(onLoadOlder).toHaveBeenCalledTimes(1);
});
it('surfaces failures and offers one explicit retry without an automatic retry loop', async () => {
const onLoadOlder = vi.fn().mockResolvedValue(false);
const { getByText, scroller, scrollTo } = renderTranscript({ onLoadOlder });
await act(async () => scrollTo(0));
expect(getByText('chat.olderLoadFailed')).toBeTruthy();
act(TestResizeObserver.resize);
fireEvent.wheel(scroller, { deltaY: -100 });
expect(onLoadOlder).toHaveBeenCalledTimes(1);
await act(async () => fireEvent.click(getByText('chat.olderLoadFailed')));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
scrollTo(500);
await act(async () => scrollTo(0));
expect(onLoadOlder).toHaveBeenCalledTimes(3);
});
it('does not hold a failure against a reader who left before it arrived', async () => {
const first = pendingPage();
const onLoadOlder = vi.fn().mockReturnValueOnce(first.promise).mockResolvedValue(true);
const { scrollTo, queryByText } = renderTranscript({ onLoadOlder });
scrollTo(0);
scrollTo(500);
await act(async () => first.land(false));
expect(queryByText('chat.olderLoadFailed')).toBeNull();
await act(async () => scrollTo(0));
expect(onLoadOlder).toHaveBeenCalledTimes(2);
});
it('keeps an old session request from settling a new session request', async () => {
const previous = pendingPage();
const current = pendingPage();
const onLoadOlder = vi.fn().mockReturnValueOnce(previous.promise).mockReturnValue(current.promise);
const { scroller, scrollTo, rerender, props, queryByText } = renderTranscript({ onLoadOlder });
scrollTo(0);
rerender({ session: { ...props.session, id: 'session-2' }, messages: messages(401, 50) });
act(flushFrames);
scrollTo(0);
expect(onLoadOlder).toHaveBeenCalledTimes(2);
await act(async () => previous.land(false));
expect(queryByText('chat.olderLoadFailed')).toBeNull();
fireEvent.wheel(scroller, { deltaY: -100 });
expect(onLoadOlder).toHaveBeenCalledTimes(2);
await act(async () => current.land(true));
});
});