Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import type {
FoldedMessage,
TurnState,
} from '@service-agent-fold/generated/types';
import { cleanup, render } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { createStore, reconcile } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { AgentMessageTarget } from '../core/search-location';
import { Transcript } from './Transcript';
const session = vi.hoisted(() => ({
sessionId: () => 'session',
metadata: () => ({ notifications: [] }),
turn: (): TurnState => 'idle',
messages: () => [] as FoldedMessage[],
quoteSelection: vi.fn(),
touch: false,
top: () => 40,
bottom: (): number => 80,
}));
vi.mock('../context/AgentSessionContext', () => ({
useAgentSession: () => session,
}));
vi.mock('@components/app/split-layout/layoutUtils', () => ({
useSplitPanel: () => ({ contentOffsetTop: session.top }),
}));
vi.mock('@components/app/mobile/float-regions/float-region-state', () => ({
FloatRegions: { hostHeight: () => session.bottom() },
}));
vi.mock('@core/mobile/isTouchDevice', () => ({
isTouchDevice: () => session.touch,
}));
vi.mock('@ui', async () => ({
cn: (...classes: string[]) => classes.join(' '),
...(await import('@ui/components/Layer')),
}));
vi.mock('./AgentMessage', () => ({
Message: (props: { message: FoldedMessage; inFlight: boolean }) => (
<span
data-in-flight={String(props.inFlight)}
data-message={`${props.message.turn}:${props.message.author.kind}`}
>
{JSON.stringify(props.message.parts)}
</span>
),
}));
vi.mock('./ReplyToSelection', () => ({
ReplyToSelection: (props: {
container?: HTMLElement;
onReply: (text: string) => void;
}) => (
<button
data-selection-connected={!!props.container}
onClick={() => props.onReply('selected text')}
>
Reply to selection
</button>
),
}));
const message = (turn: number, text = 'hello'): FoldedMessage =>
({
agentSessionId: 'session',
key: `${turn}:agent`,
turn,
author: { kind: 'agent' },
parts: [{ kind: 'text', text }],
stop: null,
}) as FoldedMessage;
// Keep the real ThreadList/Solid adapter/core. Only browser geometry and the
// expensive message renderer are substituted; jsdom has no layout engine.
let viewport = 400;
let rowHeight = 96;
const originalScrollTo = HTMLElement.prototype.scrollTo;
const observers = new Set<{
callback: ResizeObserverCallback;
elements: Set<Element>;
}>();
const resize = () => {
for (const observer of observers) {
observer.callback(
[...observer.elements].map((target) => ({
target,
contentBoxSize: [],
devicePixelContentBoxSize: [],
borderBoxSize: [
{ inlineSize: 800, blockSize: (target as HTMLElement).offsetHeight },
],
contentRect: target.getBoundingClientRect(),
})),
{} as ResizeObserver
);
}
};
const settle = async () => {
await new Promise((resolve) => setTimeout(resolve, 40));
};
beforeEach(() => {
viewport = 400;
rowHeight = 96;
session.touch = false;
session.turn = () => 'idle';
session.bottom = () => 80;
vi.stubGlobal(
'ResizeObserver',
class {
elements = new Set<Element>();
constructor(public callback: ResizeObserverCallback) {
observers.add(this);
}
observe(element: Element) {
observers.add(this);
this.elements.add(element);
}
unobserve(element: Element) {
this.elements.delete(element);
}
disconnect() {
this.elements.clear();
observers.delete(this);
}
}
);
vi.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockImplementation(
function (this: HTMLElement) {
return this.hasAttribute('data-index') ? rowHeight : viewport;
}
);
vi.spyOn(HTMLElement.prototype, 'offsetWidth', 'get').mockReturnValue(800);
vi.spyOn(HTMLElement.prototype, 'clientHeight', 'get').mockImplementation(
() => viewport
);
vi.spyOn(HTMLElement.prototype, 'scrollHeight', 'get').mockImplementation(
function (this: HTMLElement) {
return Math.max(
viewport,
Number.parseFloat(
(this.firstElementChild as HTMLElement)?.style.height
) || 0
);
}
);
vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(
function (this: HTMLElement) {
return {
width: 800,
height: this.offsetHeight,
top: 0,
left: 0,
bottom: this.offsetHeight,
right: 800,
x: 0,
y: 0,
toJSON() {},
};
}
);
HTMLElement.prototype.scrollTo = function (
options: ScrollToOptions | number = {}
) {
const top = typeof options === 'number' ? options : (options.top ?? 0);
this.scrollTop = Math.max(
0,
Math.min(top, this.scrollHeight - this.clientHeight)
);
this.dispatchEvent(new Event('scroll'));
};
});
afterEach(() => {
cleanup();
observers.clear();
vi.restoreAllMocks();
vi.unstubAllGlobals();
HTMLElement.prototype.scrollTo = originalScrollTo;
window.getSelection()?.removeAllRanges();
});
function mount(initial: FoldedMessage[]) {
const [messages, setMessages] = createSignal(initial);
session.messages = messages;
const view = render(() => <Transcript />);
const scroller = view.container.querySelector<HTMLDivElement>(
'[data-channel-scroll]'
)!;
return { ...view, scroller, setMessages };
}
describe('Transcript live turn', () => {
const inFlight = (view: { container: HTMLElement }) =>
[...view.container.querySelectorAll<HTMLElement>('[data-message]')].map(
(el) => `${el.dataset.message}=${el.dataset.inFlight}`
);
it('marks only the newest turn live, however many messages lack a stop', async () => {
// Every one of these reads `stop: null`; a superseded turn keeps it.
const [turn, setTurn] = createSignal<TurnState>('running');
session.turn = turn;
const view = mount([message(0), message(1), message(2)]);
await settle();
expect(inFlight(view)).toEqual([
'0:agent=false',
'1:agent=false',
'2:agent=true',
]);
// The runtime went away: the block stops working, and so does the tail.
setTurn('disconnected');
await settle();
expect(inFlight(view)).toEqual([
'0:agent=false',
'1:agent=false',
'2:agent=false',
]);
});
it('marks nothing live while the newest turn is a prompt awaiting its reply', async () => {
session.turn = () => 'running';
const view = mount([
message(0),
{
...message(1),
key: '1:user',
author: { kind: 'user', userId: 'u' },
} as FoldedMessage,
]);
await settle();
expect(inFlight(view)).toEqual(['0:agent=false', '1:user=false']);
});
});
describe('Transcript with the shared TanStack ThreadList', () => {
it('positions a cold-link target after the initial latest layout commits', async () => {
session.messages = () =>
Array.from({ length: 80 }, (_, turn) => message(turn));
const view = render(() => (
<Transcript searchTarget={{ messageTurn: 0, author: 'agent' }} />
));
await settle();
await settle();
const scroller = view.container.querySelector<HTMLElement>(
'[data-channel-scroll]'
)!;
expect(scroller.scrollTop).toBe(0);
expect(
view.container.querySelector(
'[data-search-target="true"] [data-message="0:agent"]'
)
).not.toBeNull();
});
it('waits for history then targets the folded author/turn, and allows repeat navigation', async () => {
const [messages, setMessages] = createSignal<FoldedMessage[]>([]);
const [target, setTarget] = createSignal<AgentMessageTarget>({
messageTurn: 0,
author: 'user',
});
session.messages = messages;
const view = render(() => <Transcript searchTarget={target()} />);
await settle();
setMessages([
{
...message(0),
key: '0:user',
author: { kind: 'user', userId: 'owner' },
} as FoldedMessage,
...Array.from({ length: 80 }, (_, turn) => message(turn)),
]);
await settle();
await settle();
const highlighted = () =>
view.container.querySelector('[data-search-target="true"]');
expect(
highlighted()?.querySelector('[data-message="0:user"]')
).not.toBeNull();
setTarget({ messageTurn: 30, author: 'agent' });
await settle();
expect(
highlighted()?.querySelector('[data-message="30:agent"]')
).not.toBeNull();
const scroller = view.container.querySelector<HTMLElement>(
'[data-channel-scroll]'
)!;
scroller.dispatchEvent(
new WheelEvent('wheel', { deltaY: 100, bubbles: true })
);
scroller.scrollTo({ top: 0 });
await settle();
expect(highlighted()).toBeNull();
setTarget({ messageTurn: 30, author: 'agent' });
await settle();
expect(
highlighted()?.querySelector('[data-message="30:agent"]')
).not.toBeNull();
const offset = scroller.scrollTop;
setMessages((previous) => [...previous, message(80)]);
await settle();
expect(scroller.scrollTop).toBe(offset);
});
it('leaves latest navigation intact when a search target is absent from the log', async () => {
session.messages = () =>
Array.from({ length: 80 }, (_, turn) => message(turn));
const view = render(() => (
<Transcript searchTarget={{ messageTurn: 100, author: 'agent' }} />
));
// ThreadList gives an unresolved initial element 1.5s before falling back.
await new Promise((resolve) => setTimeout(resolve, 1600));
expect(
view.container.querySelector('[data-search-target="true"]')
).toBeNull();
expect(
view.container.querySelector('[data-message="79:agent"]')
).not.toBeNull();
});
it('reveals the overlay on downward thumb drag and refreshes the unpinned thumb range', async () => {
const view = mount(Array.from({ length: 50 }, (_, i) => message(i)));
await settle();
view.scroller.scrollTo({ top: 500 });
await settle();
const gutter = view.scroller.nextElementSibling as HTMLElement;
const thumb = gutter.firstElementChild as HTMLElement;
let captured = false;
gutter.setPointerCapture = () => {
captured = true;
};
gutter.hasPointerCapture = () => captured;
gutter.releasePointerCapture = () => {
captured = false;
};
const pointer = (type: string, clientY: number) =>
gutter.dispatchEvent(
Object.assign(new Event(type, { bubbles: true }), {
button: 0,
pointerId: 1,
pointerType: 'mouse',
clientY,
})
);
const thumbTop = Number.parseFloat(
thumb.style.transform.slice('translateY('.length)
);
pointer('pointerdown', thumbTop + 2);
pointer('pointermove', thumbTop + 22);
// jsdom does not dispatch scroll events for direct scrollTop assignments.
view.scroller.dispatchEvent(new Event('scroll'));
pointer('pointerup', thumbTop + 22);
await settle();
expect(view.getByText('Scroll to bottom')).toBeTruthy();
const offset = view.scroller.scrollTop;
const oldHeight = Number.parseFloat(thumb.style.height);
const sizer = view.scroller.firstElementChild!;
expect(
[...observers].some((observer) => observer.elements.has(sizer))
).toBe(true);
// Change only the sizer style, without row mutations or a scroll event.
(sizer as HTMLElement).style.height =
`${view.scroller.scrollHeight + 2000}px`;
resize();
await settle();
expect(view.scroller.scrollTop).toBe(offset);
expect(Number.parseFloat(thumb.style.height)).toBeLessThan(oldHeight);
});
it('loads asynchronous history at latest with only a bounded range mounted', async () => {
const view = mount([]);
await settle();
view.setMessages(Array.from({ length: 200 }, (_, i) => message(i)));
await settle();
expect(
view.container.querySelector('[data-message="199:agent"]')
).not.toBeNull();
expect(
view.container.querySelectorAll('[data-message]').length
).toBeLessThan(30);
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
});
it('top-aligns a short transcript inside mobile insets and preserves selection wiring', async () => {
session.touch = true;
const view = mount([message(0)]);
await settle();
const row = view.container.querySelector<HTMLElement>('[data-index="0"]')!;
expect(row.style.transform).toBe(
'translateY(calc(56px - var(--channel-scroll-adjustment, 0px)))'
);
expect(view.scroller.scrollTop).toBe(0);
const reply = view.getByText('Reply to selection');
expect(reply.getAttribute('data-selection-connected')).toBe('true');
reply.click();
expect(session.quoteSelection).toHaveBeenCalledWith('selected text');
});
it('adds top padding after the floating header inset', async () => {
session.touch = true;
rowHeight = 500;
const view = mount([message(0)]);
await settle();
resize();
await settle();
const row = view.container.querySelector<HTMLElement>('[data-index="0"]')!;
expect(row.style.transform).toBe(
'translateY(calc(56px - var(--channel-scroll-adjustment, 0px)))'
);
expect(view.scroller.scrollHeight).toBe(56 + 500 + 80);
});
it('keeps a mounted row and its selection when its message object is replaced', async () => {
const view = mount([message(0)]);
await settle();
const row = view.container.querySelector('[data-index]');
const text = view.container.querySelector('[data-message]')!;
const range = document.createRange();
range.selectNode(text);
window.getSelection()!.addRange(range);
view.setMessages([message(0, 'streamed text'), message(1)]);
await settle();
expect(view.container.querySelector('[data-index]')).toBe(row);
expect(view.container.querySelector('[data-message]')).toBe(text);
expect(text.textContent).toContain('streamed text');
expect(window.getSelection()!.containsNode(text, true)).toBe(true);
view.setMessages([]);
await settle();
expect(view.container.querySelector('[data-message]')).toBeNull();
});
it('renders in-place reconciled parts updates without remounting the message', async () => {
const [messages, setMessages] = createStore([message(0, 'first token')]);
session.messages = () => messages;
const view = render(() => <Transcript />);
await settle();
const originalMessage = messages[0];
const originalParts = messages[0].parts;
const originalPart = messages[0].parts[0];
const row = view.container.querySelector('[data-index]');
const text = view.container.querySelector('[data-message]');
// The feed reconciles at an existing array index, not by replacing its
// accessor or message object. Nested store reads must remain subscribed.
setMessages(0, reconcile(message(0, 'first token and more')));
await settle();
expect(messages[0]).toBe(originalMessage);
expect(messages[0].parts).toBe(originalParts);
expect(messages[0].parts[0]).toBe(originalPart);
expect(view.container.querySelector('[data-index]')).toBe(row);
expect(view.container.querySelector('[data-message]')).toBe(text);
expect(text?.textContent).toContain('first token and more');
const next = message(0, 'finished text');
next.parts.push({ kind: 'text', text: 'a newly streamed part' });
setMessages(0, reconcile(next));
await settle();
expect(view.container.querySelector('[data-index]')).toBe(row);
expect(view.container.querySelector('[data-message]')).toBe(text);
expect(text?.textContent).toContain('finished text');
expect(text?.textContent).toContain('a newly streamed part');
});
it('follows appends and measured streaming growth only while pinned', async () => {
const view = mount(Array.from({ length: 30 }, (_, i) => message(i)));
await settle();
view.setMessages((list) => [...list, message(30)]);
await settle();
rowHeight = 140;
resize();
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
view.scroller.dispatchEvent(new WheelEvent('wheel', { deltaY: -600 }));
view.scroller.scrollTo({ top: 500 });
await settle();
const offset = view.scroller.scrollTop;
view.setMessages((list) => [...list, message(31)]);
await settle();
expect(view.scroller.scrollTop).toBe(offset);
expect(view.scroller.scrollTop).toBeLessThan(
view.scroller.scrollHeight - viewport - 50
);
});
it('keeps the end pin through keyboard squish and floating composer inset changes', async () => {
session.touch = true;
const [bottom, setBottom] = createSignal(80);
session.bottom = bottom;
const view = mount(Array.from({ length: 30 }, (_, i) => message(i)));
await settle();
viewport = 250;
resize();
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
setBottom(160);
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
view.scroller.dispatchEvent(new WheelEvent('wheel', { deltaY: -600 }));
view.scroller.scrollTo({ top: 500 });
await settle();
const offset = view.scroller.scrollTop;
setBottom(200);
viewport = 400;
resize();
await settle();
expect(view.scroller.scrollTop).toBe(offset);
});
it('reveals the shared overlay on downward intent and resumes following on click', async () => {
const view = mount(Array.from({ length: 50 }, (_, i) => message(i)));
await settle();
view.scroller.dispatchEvent(new WheelEvent('wheel', { deltaY: -600 }));
view.scroller.scrollTo({ top: 500 });
await settle();
expect(view.queryByText('Scroll to bottom')).toBeNull();
view.scroller.dispatchEvent(new WheelEvent('wheel', { deltaY: 100 }));
view.scroller.scrollTo({ top: 600 });
await settle();
view.getByText('Scroll to bottom').click();
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
expect(view.queryByText('Scroll to bottom')).toBeNull();
view.setMessages((list) => [...list, message(50)]);
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
});
it('keeps the touch jump button visible while scrolling up and jumps to latest on tap', async () => {
session.touch = true;
const view = mount(Array.from({ length: 50 }, (_, i) => message(i)));
await settle();
expect(view.queryByLabelText('Jump to latest')).toBeNull();
view.scroller.dispatchEvent(new WheelEvent('wheel', { deltaY: -600 }));
view.scroller.scrollTo({ top: 500 });
await settle();
view.getByLabelText('Jump to latest').click();
await settle();
expect(view.scroller.scrollTop).toBe(view.scroller.scrollHeight - viewport);
expect(view.queryByLabelText('Jump to latest')).toBeNull();
});
});