The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
import { PassThrough } from 'stream'
import { Box, renderSync, ScrollBox, type ScrollBoxHandle, Text } from '@hermes/ink'
import React, { useLayoutEffect, useRef } from 'react'
import { describe, expect, it, vi } from 'vitest'
import SourceBox from '../../packages/hermes-ink/src/ink/components/Box.js'
import SourceScrollBox from '../../packages/hermes-ink/src/ink/components/ScrollBox.js'
import SourceText from '../../packages/hermes-ink/src/ink/components/Text.js'
import type { DOMElement } from '../../packages/hermes-ink/src/ink/dom.js'
import Output from '../../packages/hermes-ink/src/ink/output.js'
import { scrollFastPathStats as sourceScrollFastPathStats } from '../../packages/hermes-ink/src/ink/render-node-to-output.js'
import { renderSync as renderSourceSync } from '../../packages/hermes-ink/src/ink/root.js'
import { useVirtualHistory } from '../hooks/useVirtualHistory.js'
interface Item {
height: number
heightAfterResize?: number
key: string
text?: string
}
interface Exposed {
scroll: ScrollBoxHandle | null
virtualHistory: ReturnType<typeof useVirtualHistory>
}
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
const makeStreams = () => {
const stdout = new PassThrough()
const stdin = new PassThrough()
const stderr = new PassThrough()
Object.assign(stdout, { columns: 80, isTTY: false, rows: 20 })
Object.assign(stdin, { isTTY: false })
Object.assign(stderr, { isTTY: false })
stdout.on('data', () => {})
return { stderr, stdin, stdout }
}
const itemHeightForColumns = (item: Item | undefined, columns: number) =>
columns >= 80 ? (item?.heightAfterResize ?? item?.height ?? 1) : (item?.height ?? 1)
function Harness({
columns = 80,
expose,
height = 10,
generation = 0,
initialHeights,
items,
maxMounted = 16
}: {
columns?: number
expose: React.MutableRefObject<Exposed | null>
height?: number
generation?: number
initialHeights?: ReadonlyMap<string, number>
items: readonly Item[]
maxMounted?: number
}) {
const scrollRef = useRef<ScrollBoxHandle | null>(null)
const virtualHistory = useVirtualHistory(scrollRef, items, columns, {
coldStartCount: 16,
estimateHeight: index => itemHeightForColumns(items[index], columns),
generation,
initialHeights,
maxMounted,
overscan: 2
})
useLayoutEffect(() => {
expose.current = { scroll: scrollRef.current, virtualHistory }
})
return React.createElement(
ScrollBox,
{ flexDirection: 'column', height, ref: scrollRef, stickyScroll: true },
React.createElement(
Box,
{ flexDirection: 'column', width: '100%' },
virtualHistory.topSpacer > 0 ? React.createElement(Box, { height: virtualHistory.topSpacer }) : null,
...items.slice(virtualHistory.start, virtualHistory.end).map(item =>
React.createElement(
Box,
{
height: itemHeightForColumns(item, columns),
key: item.key,
ref: virtualHistory.measureRef(item.key)
},
React.createElement(Text, null, item.text ?? item.key)
)
),
virtualHistory.bottomSpacer > 0 ? React.createElement(Box, { height: virtualHistory.bottomSpacer }) : null
)
)
}
function CorruptGeometryHarness({ expose, tick }: { expose: React.MutableRefObject<DOMElement[]>; tick: number }) {
const nodes = useRef<DOMElement[]>([])
useLayoutEffect(() => {
expose.current = nodes.current
})
return React.createElement(
ScrollBox,
{ flexDirection: 'column', height: 8 },
...['nan-top', 'positive-infinity', 'negative-infinity', 'billion-rows', 'clipped-huge-fill'].map((label, index) =>
React.createElement(
Box,
{
backgroundColor: 'blue',
borderStyle: label === 'clipped-huge-fill' ? 'single' : undefined,
height: 1,
key: label,
opaque: true,
ref: node => {
if (node) {
nodes.current[index] = node
}
},
width: '100%'
},
React.createElement(Text, null, `${label}-${tick}`)
)
),
React.createElement(
Box,
{
height: 1,
ref: node => {
if (node) {
nodes.current[5] = node
}
}
},
React.createElement(Text, null, React.createElement(Text, null, `nested-corrupt-${tick}`))
),
React.createElement(Text, null, `adjacent-valid-${tick}`),
React.createElement(Box, { height: 20 }, React.createElement(Text, null, `tail-${tick}`))
)
}
interface FastPathRepairExpose {
adjacent: DOMElement | null
dirtyChild: DOMElement | null
overlay: DOMElement | null
scroll: ScrollBoxHandle | null
scrollBox: DOMElement | null
}
function FastPathRepairHarness({
expose,
tick,
dirtyTick = tick,
includeOverlay = true
}: {
dirtyTick?: number
expose: React.MutableRefObject<FastPathRepairExpose | null>
includeOverlay?: boolean
tick: number
}) {
return React.createElement(
SourceBox,
{ flexDirection: 'column', height: 12, width: 40 },
React.createElement(
SourceScrollBox,
{
flexDirection: 'column',
height: 8,
ref: scroll => {
if (expose.current) {
expose.current.scroll = scroll
}
},
width: 40
},
React.createElement(SourceBox, { height: 2 }, React.createElement(SourceText, null, 'head-row')),
React.createElement(
SourceBox,
{
height: 2,
ref: dirtyChild => {
if (expose.current) {
expose.current.dirtyChild = dirtyChild
expose.current.scrollBox = dirtyChild?.parentNode?.parentNode ?? null
}
}
},
React.createElement(SourceText, null, `dirty-row-${dirtyTick}`)
),
React.createElement(SourceBox, { height: 20 }, React.createElement(SourceText, null, 'tail-row'))
),
includeOverlay
? React.createElement(
SourceBox,
{
height: 2,
left: 0,
position: 'absolute',
ref: overlay => {
if (expose.current) {
expose.current.overlay = overlay
}
},
top: 2,
width: 40
},
React.createElement(SourceText, null, 'overlay-row')
)
: null,
React.createElement(
SourceBox,
{
height: 1,
ref: adjacent => {
if (expose.current) {
expose.current.adjacent = adjacent
}
}
},
React.createElement(SourceText, null, `adjacent-fast-path-${tick}`)
)
)
}
function guardFastPathRepairAllocations(maxWidth: number, maxHeight: number) {
const originalArrayFill = Array.prototype.fill
const originalBlit = Output.prototype.blit
const originalClear = Output.prototype.clear
const originalRepeat = String.prototype.repeat
const originalWrite = Output.prototype.write
const observed = {
largestArrayRows: 0,
largestBlitHeight: 0,
largestBlitWidth: 0,
largestClearHeight: 0,
largestClearWidth: 0,
largestRepeat: 0,
largestWrite: 0,
repairWhitespaceWrites: 0
}
vi.spyOn(String.prototype, 'repeat').mockImplementation(function (count: number) {
observed.largestRepeat = Math.max(observed.largestRepeat, count)
if (!Number.isSafeInteger(count) || count < 0 || count > maxWidth) {
throw new Error(`unbounded fast-path repeat: ${count}`)
}
return originalRepeat.call(this, count)
})
vi.spyOn(Array.prototype, 'fill').mockImplementation(function (
this: unknown[],
value: unknown,
start?: number,
end?: number
) {
observed.largestArrayRows = Math.max(observed.largestArrayRows, this.length)
if (this.length > maxHeight) {
throw new Error(`unbounded fast-path row array: ${this.length}`)
}
return Reflect.apply(originalArrayFill, this, [value, start, end])
} as typeof Array.prototype.fill)
vi.spyOn(Output.prototype, 'blit').mockImplementation(function (...args: Parameters<Output['blit']>) {
observed.largestBlitWidth = Math.max(observed.largestBlitWidth, args[3])
observed.largestBlitHeight = Math.max(observed.largestBlitHeight, args[4])
return originalBlit.apply(this, args)
})
vi.spyOn(Output.prototype, 'clear').mockImplementation(function (...args: Parameters<Output['clear']>) {
observed.largestClearWidth = Math.max(observed.largestClearWidth, args[0].width)
observed.largestClearHeight = Math.max(observed.largestClearHeight, args[0].height)
return originalClear.apply(this, args)
})
vi.spyOn(Output.prototype, 'write').mockImplementation(function (...args: Parameters<Output['write']>) {
observed.largestWrite = Math.max(observed.largestWrite, args[2].length)
if (args[2].length > 0 && /^[ \n]+$/.test(args[2])) {
observed.repairWhitespaceWrites++
}
if (args[2].length > maxWidth * maxHeight + maxHeight) {
throw new Error(`unbounded fast-path Output.write input: ${args[2].length}`)
}
return originalWrite.apply(this, args)
})
return observed
}
describe('ScrollBox renderer bounds', () => {
it('rejects invalid imperative geometry without poisoning scroll state', async () => {
const items = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
const expose = { current: null as Exposed | null }
const streams = makeStreams()
const instance = renderSync(React.createElement(Harness, { expose, items }), {
patchConsole: false,
stderr: streams.stderr as NodeJS.WriteStream,
stdin: streams.stdin as NodeJS.ReadStream,
stdout: streams.stdout as NodeJS.WriteStream
})
try {
await delay(20)
const scroll = expose.current!.scroll!
scroll.scrollTo(4)
scroll.scrollTo(Number.NaN)
scroll.scrollBy(Number.POSITIVE_INFINITY)
scroll.adjustScrollTop(Number.NEGATIVE_INFINITY)
scroll.setClampBounds(Number.NaN, Number.POSITIVE_INFINITY)
await delay(20)
expect(scroll.getScrollTop()).toBe(4)
expect(scroll.getPendingDelta()).toBe(0)
expect(Number.isFinite(scroll.getScrollHeight())).toBe(true)
} finally {
instance.unmount()
instance.cleanup()
}
})
it('fails closed on corrupt ScrollBox child geometry and keeps adjacent rows renderable', async () => {
const expose = { current: [] as DOMElement[] }
const streams = makeStreams()
const originalRepeat = String.prototype.repeat
const originalWrite = Output.prototype.write
let largestWriteInput = 0
let largestWrite = 0
let output = ''
vi.spyOn(String.prototype, 'repeat').mockImplementation(function (count: number) {
if (!Number.isSafeInteger(count) || count < 0 || count > 10_000) {
throw new Error(`unbounded string repeat: ${count}`)
}
return originalRepeat.call(this, count)
})
vi.spyOn(Output.prototype, 'write').mockImplementation(function (...args: Parameters<Output['write']>) {
largestWriteInput = Math.max(largestWriteInput, args[2].length)
if (args[2].length > 10_000) {
throw new Error(`unbounded Output.write input: ${args[2].length}`)
}
return originalWrite.apply(this, args)
})
streams.stdout.removeAllListeners('data')
streams.stdout.on('data', chunk => {
largestWrite = Math.max(largestWrite, chunk.length)
output += chunk.toString()
})
const instance = renderSync(React.createElement(CorruptGeometryHarness, { expose, tick: 0 }), {
patchConsole: false,
stderr: streams.stderr as NodeJS.WriteStream,
stdin: streams.stdin as NodeJS.ReadStream,
stdout: streams.stdout as NodeJS.WriteStream
})
try {
await delay(20)
const [nanTop, positiveInfinity, negativeInfinity, billionRows, clippedHugeFill, nestedTextWrapper] =
expose.current
expect(nanTop?.yogaNode).toBeDefined()
expect(positiveInfinity?.yogaNode).toBeDefined()
expect(negativeInfinity?.yogaNode).toBeDefined()
expect(billionRows?.yogaNode).toBeDefined()
expect(clippedHugeFill?.yogaNode).toBeDefined()
expect(nestedTextWrapper?.yogaNode).toBeDefined()
const nestedText = nestedTextWrapper!.childNodes.find(child => child.nodeName === 'ink-text') as
DOMElement | undefined
const nestedTextChild = nestedText?.childNodes[0]
expect(nestedTextChild).toBeDefined()
vi.spyOn(nanTop!.yogaNode!, 'getComputedTop').mockReturnValue(Number.NaN)
vi.spyOn(positiveInfinity!.yogaNode!, 'getComputedHeight').mockReturnValue(Number.POSITIVE_INFINITY)
vi.spyOn(negativeInfinity!.yogaNode!, 'getComputedHeight').mockReturnValue(Number.NEGATIVE_INFINITY)
vi.spyOn(billionRows!.yogaNode!, 'getComputedHeight').mockReturnValue(1_000_000_000)
vi.spyOn(clippedHugeFill!.yogaNode!, 'getComputedHeight').mockReturnValue(100_000_000)
vi.spyOn(clippedHugeFill!.yogaNode!, 'getComputedWidth').mockReturnValue(100_000_000)
let nestedOffsetX = 0
let nestedOffsetY = 0
nestedTextChild!.yogaNode = {
getComputedLeft: () => nestedOffsetX,
getComputedTop: () => nestedOffsetY
} as DOMElement['yogaNode']
output = ''
largestWrite = 0
largestWriteInput = 0
const corruptNestedOffsets = [
[Number.NaN, 0],
[Number.POSITIVE_INFINITY, 0],
[Number.NEGATIVE_INFINITY, 0],
[-1, 0],
[0.5, 0],
[100_000_000, 0],
[0, Number.NaN],
[0, Number.POSITIVE_INFINITY],
[0, Number.NEGATIVE_INFINITY],
[0, -1],
[0, 0.5],
[0, 100_000_000]
] as const
for (const [index, [offsetX, offsetY]] of corruptNestedOffsets.entries()) {
nestedOffsetX = offsetX
nestedOffsetY = offsetY
expect(() => {
instance.rerender(React.createElement(CorruptGeometryHarness, { expose, tick: index + 1 }))
}).not.toThrow()
await delay(5)
}
await delay(40)
expect(output).toContain(`adjacent-valid-${corruptNestedOffsets.length}`)
expect(largestWriteInput).toBeLessThan(10_000)
expect(largestWrite).toBeLessThan(10_000)
expect(output.length).toBeLessThan(50_000)
} finally {
vi.restoreAllMocks()
instance.unmount()
instance.cleanup()
}
})
it('clips corrupt dirty-child DECSTBM repairs before allocating or recursing', async () => {
const expose = {
current: {
adjacent: null,
dirtyChild: null,
overlay: null,
scroll: null,
scrollBox: null
} as FastPathRepairExpose
}
const streams = makeStreams()
let output = ''
const instance = renderSourceSync(
React.createElement(FastPathRepairHarness, { expose, includeOverlay: false, tick: 0 }),
{
patchConsole: false,
stderr: streams.stderr as NodeJS.WriteStream,
stdin: streams.stdin as NodeJS.ReadStream,
stdout: streams.stdout as NodeJS.WriteStream
}
)
try {
await delay(20)
const dirtyChild = expose.current!.dirtyChild!
expect(dirtyChild, streams.stderr.read()?.toString()).not.toBeNull()
expect(dirtyChild.yogaNode).toBeDefined()
vi.spyOn(dirtyChild.yogaNode!, 'getComputedTop').mockReturnValue(-99_999_995)
vi.spyOn(dirtyChild.yogaNode!, 'getComputedWidth').mockReturnValue(100_000_000)
vi.spyOn(dirtyChild.yogaNode!, 'getComputedHeight').mockReturnValue(100_000_000)
instance.rerender(React.createElement(FastPathRepairHarness, { expose, includeOverlay: false, tick: 1 }))
await delay(20)
streams.stdout.removeAllListeners('data')
streams.stdout.on('data', chunk => {
output += chunk.toString()
})
const observed = guardFastPathRepairAllocations(80, 20)
const fastPathsBefore = sourceScrollFastPathStats.taken
const capturedBefore = sourceScrollFastPathStats.captured
expect(() => expose.current!.scroll!.scrollTo(1)).not.toThrow()
expect(() =>
instance.rerender(React.createElement(FastPathRepairHarness, { expose, includeOverlay: false, tick: 2 }))
).not.toThrow()
await delay(40)
expect(sourceScrollFastPathStats.captured, JSON.stringify(sourceScrollFastPathStats)).toBeGreaterThan(
capturedBefore
)
expect(sourceScrollFastPathStats.taken, JSON.stringify(sourceScrollFastPathStats)).toBeGreaterThan(
fastPathsBefore
)
expect(observed.repairWhitespaceWrites).toBeGreaterThan(0)
expect(observed.largestRepeat).toBeGreaterThan(0)
expect(observed.largestArrayRows).toBeGreaterThan(0)
output = ''
expect(() =>
instance.rerender(
React.createElement(FastPathRepairHarness, {
dirtyTick: 2,
expose,
includeOverlay: false,
tick: 3
})
)
).not.toThrow()
await delay(40)
expect(observed.largestRepeat).toBeLessThanOrEqual(80)
expect(observed.largestArrayRows).toBeLessThanOrEqual(20)
expect(observed.largestBlitWidth).toBeLessThanOrEqual(80)
expect(observed.largestBlitHeight).toBeLessThanOrEqual(20)
expect(observed.largestClearWidth).toBeLessThanOrEqual(80)
expect(observed.largestClearHeight).toBeLessThanOrEqual(20)
expect(observed.largestWrite).toBeLessThanOrEqual(1_620)
expect(expose.current!.scroll!.getScrollTop()).toBe(1)
expect(expose.current!.scroll!.getViewportHeight()).toBeGreaterThan(0)
expect(output).toContain('adjacent-fast-path-3')
expect(streams.stderr.read()?.toString() ?? '').toBe('')
} finally {
vi.restoreAllMocks()
instance.unmount()
instance.cleanup()
}
})
it('clips corrupt absolute-overlay DECSTBM repairs before allocating or recursing', async () => {
const expose = {
current: {
adjacent: null,
dirtyChild: null,
overlay: null,
scroll: null,
scrollBox: null
} as FastPathRepairExpose
}
const streams = makeStreams()
let output = ''
const instance = renderSourceSync(React.createElement(FastPathRepairHarness, { expose, tick: 0 }), {
patchConsole: false,
stderr: streams.stderr as NodeJS.WriteStream,
stdin: streams.stdin as NodeJS.ReadStream,
stdout: streams.stdout as NodeJS.WriteStream
})
try {
await delay(20)
const overlay = expose.current!.overlay!
const scrollBox = expose.current!.scrollBox!
expect(overlay, streams.stderr.read()?.toString()).not.toBeNull()
expect(overlay.yogaNode).toBeDefined()
expect(scrollBox.yogaNode).toBeDefined()
vi.spyOn(scrollBox.yogaNode!, 'getComputedWidth').mockReturnValue(100_000_000)
vi.spyOn(overlay.yogaNode!, 'getComputedWidth').mockReturnValue(100_000_000)
vi.spyOn(overlay.yogaNode!, 'getComputedHeight').mockReturnValue(100_000_000)
instance.rerender(React.createElement(FastPathRepairHarness, { expose, tick: 1 }))
await delay(20)
instance.rerender(React.createElement(FastPathRepairHarness, { expose, tick: 1 }))
await delay(20)
streams.stdout.removeAllListeners('data')
streams.stdout.on('data', chunk => {
output += chunk.toString()
})
const observed = guardFastPathRepairAllocations(80, 20)
const fastPathsBefore = sourceScrollFastPathStats.taken
const capturedBefore = sourceScrollFastPathStats.captured
expect(() => expose.current!.scroll!.scrollTo(1)).not.toThrow()
expect(expose.current!.scroll!.getScrollTop()).toBe(1)
await delay(40)
expect(sourceScrollFastPathStats.captured, JSON.stringify(sourceScrollFastPathStats)).toBeGreaterThan(
capturedBefore
)
expect(sourceScrollFastPathStats.taken, JSON.stringify(sourceScrollFastPathStats)).toBeGreaterThan(
fastPathsBefore
)
expect(observed.repairWhitespaceWrites).toBeGreaterThan(0)
expect(observed.largestRepeat).toBeGreaterThan(0)
expect(observed.largestArrayRows).toBeGreaterThan(0)
output = ''
expect(() =>
instance.rerender(React.createElement(FastPathRepairHarness, { dirtyTick: 1, expose, tick: 2 }))
).not.toThrow()
await delay(40)
expect(observed.largestRepeat).toBeLessThanOrEqual(80)
expect(observed.largestArrayRows).toBeLessThanOrEqual(20)
expect(observed.largestBlitWidth).toBeLessThanOrEqual(80)
expect(observed.largestBlitHeight).toBeLessThanOrEqual(20)
expect(observed.largestClearWidth).toBeLessThanOrEqual(80)
expect(observed.largestClearHeight).toBeLessThanOrEqual(20)
expect(observed.largestWrite).toBeLessThanOrEqual(1_620)
expect(output.length).toBeLessThan(2_000)
expect(expose.current!.scroll!.getViewportHeight()).toBeGreaterThan(0)
expect(output).toContain('adjacent-fast-path-2')
expect(streams.stderr.read()?.toString() ?? '').toBe('')
} finally {
vi.restoreAllMocks()
instance.unmount()
instance.cleanup()
}
})
})