Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

23.0 KB
Raw Blame
import { createElement, useMemo, type ReactElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, expect, it, vi } from 'vitest'
import type { AgentJournalRenderItem } from '../../../src/shared/agent-session-journal-types'
import { projectStructuredAgentSessionMessages } from '../../../src/shared/structured-agent-session-message-projection'
import { agentJournalTurnBody } from '../../../src/shared/agent-session-turn-record'
import { foldMobileNativeChatMessages } from './mobile-native-chat-render-data'
import { useMobileStructuredAgentTurnTiming } from './use-mobile-structured-agent-turn-timing'
import { MobileNativeChatPageList } from './MobileNativeChatPageList'
import type {
  NativeChatMessage,
  NativeChatToolResultBlock
} from '../../../src/shared/native-chat-types'
import { MobileNativeChatOverlay } from './MobileNativeChatOverlay'
import type * as MobileNativeChatItemReadModule from './mobile-native-chat-item-read'
import type * as MobileNativeChatRowPropsModule from './native-chat/transcript/use-mobile-native-chat-row-props'
import type * as MobileNativeChatRowProjectionModule from './native-chat/transcript/mobile-native-chat-row-projection'
import type * as MobileNativeChatMessageDetailModule from './native-chat/transcript/use-mobile-native-chat-message-detail'
import type { MobileNativeChatController } from './mobile-native-chat-controller-contract'
import { stubRpcClient } from '../transport/rpc-client-test-stub'
import { MobileNativeChatView } from './MobileNativeChatView'
import { MobileNativeChatRowContent } from './native-chat/transcript/MobileNativeChatRowItemSource'

vi.mock('react-native', async () => ({
  ActivityIndicator: 'ActivityIndicator',
  ScrollView: 'ScrollView',
  Platform: { OS: 'web' },
  Pressable: 'Pressable',
  StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 },
  Text: 'Text',
  View: 'View'
}))
vi.mock('react-native-safe-area-context', () => ({
  useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 })
}))
vi.mock('react-native-gesture-handler', () => {
  const chain = { runOnJS: () => chain, onStart: () => chain, onUpdate: () => chain }
  return {
    Gesture: { Simultaneous: () => ({}), Native: () => ({}), Pinch: () => chain },
    GestureDetector: 'GestureDetector',
    GestureHandlerRootView: 'GestureHandlerRootView'
  }
})
vi.mock('lucide-react-native', () => ({
  ArrowDown: 'ArrowDown',
  Brain: 'Brain',
  ChevronRight: 'ChevronRight',
  ChevronsDownUp: 'ChevronsDownUp',
  ChevronsUpDown: 'ChevronsUpDown',
  Square: 'Square'
}))
vi.mock('../components/MobileMarkdown', () => ({ MobileMarkdown: 'MobileMarkdown' }))
const itemReads = vi.hoisted(() => vi.fn())
vi.mock('./mobile-native-chat-item-read', async (importOriginal) => ({
  ...(await importOriginal<typeof MobileNativeChatItemReadModule>()),
  readMobileNativeChatItem: itemReads
}))
const operations = vi.hoisted(() => ({
  resolve: new Array<string>(),
  compare: new Array<string>(),
  raw: new Array<string>(),
  state: new Array<string>()
}))
vi.mock('./native-chat/transcript/use-mobile-native-chat-row-props', async (importOriginal) => {
  const actual = await importOriginal<typeof MobileNativeChatRowPropsModule>()
  return {
    ...actual,
    resolveMobileNativeChatRowProps(
      ...args: Parameters<typeof actual.resolveMobileNativeChatRowProps>
    ) {
      operations.resolve.push(args[1].id)
      return actual.resolveMobileNativeChatRowProps(...args)
    }
  }
})
vi.mock('./native-chat/transcript/mobile-native-chat-row-projection', async (importOriginal) => {
  const actual = await importOriginal<typeof MobileNativeChatRowProjectionModule>()
  return {
    equalMobileNativeChatRowContent(
      ...args: Parameters<typeof actual.equalMobileNativeChatRowContent>
    ) {
      operations.compare.push(args[1].message.id)
      return actual.equalMobileNativeChatRowContent(...args)
    }
  }
})
vi.mock(
  './native-chat/transcript/use-mobile-native-chat-message-detail',
  async (importOriginal) => {
    const actual = await importOriginal<typeof MobileNativeChatMessageDetailModule>()
    return {
      ...actual,
      useMobileNativeChatMessageDetail(
        ...args: Parameters<typeof actual.useMobileNativeChatMessageDetail>
      ) {
        const result = actual.useMobileNativeChatMessageDetail(...args),
          detail = result.detail
        return detail
          ? {
              ...result,
              detail: {
                ...detail,
                raw: (id: string) => {
                  operations.raw.push(id)
                  return detail.raw(id)
                },
                state: (id: string) => {
                  operations.state.push(id)
                  return detail.state(id)
                }
              }
            }
          : result
      }
    }
  }
)
const rendered = vi.hoisted(() => new Map<string, number>())
vi.mock('./native-chat/transcript/MobileNativeChatMessage', async () => {
  const React = await import('react')
  const { useMobileNativeChatFullMessage, MobileNativeChatToolOutput } =
    await import('./MobileNativeChatFullContent')
  const { MobileNativeChatGroupedThought } =
    await import('./native-chat/transcript/MobileNativeChatReasoningRow')
  return {
    MobileNativeChatMessage: React.memo(
      (props: { message: NativeChatMessage; workRun?: NativeChatMessage[] }) => {
        const full = useMobileNativeChatFullMessage(props.message)
        rendered.set(props.message.id, (rendered.get(props.message.id) ?? 0) + 1)
        return React.createElement(
          'ChatMessage',
          { ...props, recovery: full.recovery },
          full.showFull,
          ...(props.workRun ?? [])
            .filter((member) => member.role === 'reasoning')
            .map((member) =>
              React.createElement(MobileNativeChatGroupedThought, {
                key: member.id,
                message: member,
                fontScale: 1,
                expanded: true,
                onToggle: () => {}
              })
            ),
          ...(props.workRun ?? [props.message]).flatMap((member) =>
            member.blocks.flatMap((body, index) =>
              body.type === 'tool-result' && body.fullOutputItemId
                ? React.createElement(MobileNativeChatToolOutput, {
                    key: index,
                    body,
                    type: {},
                    rootIdentity: 'run',
                    positionKey: 'output'
                  })
                : []
            )
          )
        )
      }
    )
  }
})
vi.mock('./native-chat/input/MobileNativeChatPromptCard', () => ({
  MobileNativeChatPromptCard: 'PromptCard'
}))
vi.mock('./native-chat/transcript/MobileNativeChatLiveLine', () => ({
  MobileNativeChatLiveLine: 'LiveStatus'
}))
vi.mock('./MobileAgentWorkingIndicator', () => ({
  MobileAgentWorkingIndicator: 'WorkingIndicator'
}))
vi.mock('../components/ActionSheetModal', () => ({ ActionSheetModal: 'ActionSheetModal' }))
vi.mock('./native-chat/input/MobileNativeChatAsk', () => ({ MobileNativeChatAsk: 'ChatAsk' }))
vi.mock('./native-chat/input/MobileNativeChatPermission', () => ({
  MobileNativeChatPermission: 'ChatPermission'
}))
vi.mock('./native-chat/input/MobileNativeChatQuestion', () => ({
  MobileNativeChatQuestion: 'ChatQuestion'
}))
vi.mock('../platform/use-reduced-motion', () => ({ useReducedMotionEnabled: () => true }))
vi.mock('./native-chat/input/MobileNativeChatQueuedMessages', () => ({
  MobileNativeChatQueuedMessages: 'Queued'
}))
vi.mock('./native-chat/input/MobileNativeChatBackgroundTasks', () => ({
  MobileNativeChatBackgroundTasks: 'BackgroundTasks'
}))
vi.mock('./native-chat/visual/MobileNativeChatImageViewer', () => ({
  MobileNativeChatImageViewer: 'ImageViewer'
}))
vi.mock('./native-chat/transcript/MobileNativeChatMessageActionsSheet', () => ({
  MobileNativeChatMessageActionsSheet: 'ActionsSheet'
}))
vi.mock('./native-chat/composer/MobileNativeChatComposer', () => ({
  MobileNativeChatDraftComposer: 'Composer'
}))

const stable = {
  onSend: async () => true,
  sendSurfaceId: 'perf-chat',
  getSendCompletionGeneration: () => 0,
  getComposerEditGeneration: () => 0,
  draftKey: null,
  onComposerTextChange: () => {},
  pending: [
    {
      id: 'pending',
      text: 'follow up',
      sentAt: 10
    }
  ],
  imagePreviewsByMessageId: { 'user-0': ['local:preview'] }
}

const itemSource = { client: stubRpcClient(), sessionId: 'session' }
function Harness({
  items,
  source = itemSource
}: {
  items: AgentJournalRenderItem[]
  source?: typeof itemSource | null
}) {
  const messages = useMemo(() => projectStructuredAgentSessionMessages(items, [], []), [items])
  const timing = useMobileStructuredAgentTurnTiming(
    { items, submissions: [], working: true },
    'live'
  )
  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the overlay only reads these controller members; no other controller flow is mounted.
  const controller = {
    showNativeChat: true,
    nativeChatSession: { messages, status: 'ready' },
    nativeChatAgent: 'claude',
    nativeChatStructured: true,
    nativeChatTurnActive: true,
    nativeChatItemSource: source,
    nativeChatVisualSource: source,
    nativeChatSettledTurns: timing.settledTurns,
    nativeChatTurnJournal: timing.turnJournal,
    nativeChatWorkingStartedAt: timing.workingStartedAt,
    chatPending: stable.pending,
    chatImagePreviewsByMessageId: stable.imagePreviewsByMessageId,
    chatDraftKey: null,
    setChatComposerText: stable.onComposerTextChange,
    getChatComposerEditGeneration: stable.getComposerEditGeneration,
    nativeChatQueued: { cards: [], pause: null, sessionKey: 'session' }
  } as unknown as MobileNativeChatController
  return createElement(MobileNativeChatOverlay, {
    controller,
    onOpenFile: stable.onComposerTextChange,
    images: {
      attachments: [],
      isAttaching: false,
      attachImage: async () => {},
      removeAttachment: () => {},
      sendNativeChat: stable.onSend
    },
    onMicPress: undefined,
    micActive: false,
    micStarting: false,
    micProcessing: false,
    dictationMode: undefined,
    onMicPressIn: () => {},
    onMicPressOut: () => {},
    inputLockReason: null,
    sendErrorMessage: null,
    onClearSendError: () => {},
    sendSurfaceId: source?.sessionId ?? stable.sendSurfaceId,
    sessionId: source?.sessionId ?? 'session',
    getSendCompletionGeneration: stable.getSendCompletionGeneration,
    keyboardInset: 0,
    hostName: null
  })
}

const textBody = (role: 'user' | 'assistant' | 'reasoning', text: string) => ({
  kind: 'message' as const,
  role,
  blocks: [{ type: 'text' as const, text }]
})

function journal(turns: number, text: string): AgentJournalRenderItem[] {
  const items: AgentJournalRenderItem[] = []
  const add = (itemId: string, body: AgentJournalRenderItem['body']) => {
    items.push({
      itemId,
      body,
      revision: 1,
      sequence: items.length + 1,
      observedAt: 1000 + items.length
    })
  }
  for (let i = 0; i < turns; i++) {
    const turnId = `turn-${i}`
    add(`user-${i}`, textBody('user', 'inspect the code'))
    add(`tool-${i}`, {
      kind: 'message',
      role: 'assistant',
      blocks: [
        { type: 'tool-call', name: 'Read', callId: `call-${i}`, input: { path: 'index.ts' } },
        { type: 'tool-result', callId: `call-${i}`, output: 'contents' }
      ]
    })
    add(`reason-${i}`, textBody('reasoning', 'checking'))
    add(`answer-${i}`, textBody('assistant', 'finished'))
    add(
      `lifecycle-${i}`,
      agentJournalTurnBody({
        turnId,
        userItemId: `user-${i}`,
        state: 'completed',
        startedAt: 1000,
        completedAt: 5000,
        durationMs: 4000
      })
    )
  }
  add('live-user', textBody('user', 'continue'))
  add(
    'live-turn',
    agentJournalTurnBody({
      turnId: 'live',
      userItemId: 'live-user',
      state: 'running',
      startedAt: 6000
    })
  )
  add('live-answer', textBody('assistant', text))
  return items
}

const listeners = new Map<string, () => void>()
const scroller = {
  scrollTop: 0,
  scrollHeight: 10000,
  clientHeight: 500,
  addEventListener: (type: string, callback: () => void) => listeners.set(type, callback),
  removeEventListener: (type: string) => listeners.delete(type),
  querySelectorAll: () => [],
  querySelector: () => null,
  getBoundingClientRect: () => ({ top: 0, bottom: 500 })
}
const nodeMock = (element: { type: unknown }) =>
  element.type === 'ScrollView'
    ? { getScrollableNode: () => scroller, getInnerViewNode: () => null }
    : null
let renderer: ReactTestRenderer | null = null
function showElement(element: ReactElement) {
  act(() => {
    if (renderer) {
      renderer.update(element)
    } else {
      renderer = create(element, { createNodeMock: nodeMock })
    }
  })
}
afterEach(() => {
  act(() => renderer?.unmount())
  renderer = null
  rendered.clear()
  itemReads.mockReset()
  vi.useRealTimers()
})

function measure(turns: number, all: boolean) {
  scroller.scrollHeight = all ? 100 : 10000
  scroller.clientHeight = all ? 100 : 500
  const items = journal(turns, 'hello')
  showElement(createElement(Harness, { items }))
  expect(renderer!.root.findAllByType(MobileNativeChatPageList)).toHaveLength(1)
  const mounted = renderer!.root.findAll((node) => Object.is(node.type, 'ChatMessage'))
  const total =
    foldMobileNativeChatMessages(projectStructuredAgentSessionMessages(items, [], []), 'claude')
      .length + 1
  expect(mounted.length).toBe(all ? total : 24)
  const mountedIds = new Set(mounted.map((node) => node.props.message.id))
  const members = new Set(
    mounted.flatMap((node) =>
      (node.props.workRun ?? [node.props.message]).map((member: NativeChatMessage) => member.id)
    )
  )
  const maximum = { resolve: 0, compare: 0, raw: 0, state: 0 }
  for (let batch = 0; batch < 20; batch++) {
    rendered.clear()
    const updated = items.map((item) =>
      item.itemId === 'live-answer'
        ? {
            ...item,
            revision: batch + 2,
            body: textBody('assistant', `hello${'.'.repeat(batch + 1)}`)
          }
        : item
    )
    Object.values(operations).forEach((ids) => ids.splice(0))
    act(() => renderer!.update(createElement(Harness, { items: updated })))
    expect([...rendered.keys()]).toEqual(['live-answer'])
    for (const key of ['resolve', 'compare', 'raw', 'state'] as const) {
      expect(
        operations[key].every((id) =>
          (key === 'resolve' || key === 'compare' ? mountedIds : members).has(id)
        )
      ).toBe(true)
      expect(operations[key].length).toBeLessThanOrEqual(
        key === 'resolve' || key === 'compare' ? mounted.length : 2 * mounted.length
      )
      maximum[key] = Math.max(maximum[key], operations[key].length)
    }
  }
  return maximum
}

it.each([false, true])('bounds final work at mounted rows only, all history: %s', (all) => {
  const small = measure(10, all)
  act(() => renderer?.unmount())
  renderer = null
  const large = measure(100, all)
  for (const operation of ['resolve', 'compare', 'raw', 'state'] as const) {
    expect(large[operation]).toBeLessThanOrEqual(all ? 10 * small[operation] : small[operation])
  }
})
it('reuses footer rows during a command and returns them to the list afterward', () => {
  const base = journal(0, 'hello').map((item) =>
    item.body.kind === 'message' && item.body.role === 'user'
      ? { ...item, body: { ...item.body, command: { name: 'compact' } } }
      : item
  )
  const show = (text: string, holding = true) =>
    act(() => {
      const items = base.map((item) =>
        item.itemId === 'live-answer'
          ? { ...item, body: textBody('assistant', text) }
          : !holding && item.body.kind === 'message'
            ? { ...item, body: { ...item.body, command: undefined } }
            : item
      )
      const held: NativeChatMessage = {
        id: 'held',
        role: 'user',
        blocks: [{ type: 'text', text: 'next' }],
        timestamp: 3,
        source: 'transcript',
        queued: true
      }
      const folded = [...projectStructuredAgentSessionMessages(items, [], []), held]
      const element = createElement(MobileNativeChatView, {
        ...stable,
        pending: [],
        messages: folded,
        folded,
        status: 'ready',
        streaming: null,
        agentWorking: true,
        structuredActivityUi: true,
        turnJournal: { items, submissions: [] }
      })
      showElement(element)
    })
  const listed = (): string[] =>
    renderer!.root
      .findByType(MobileNativeChatPageList)
      .props.rows.map((row: NativeChatMessage) => row.id)
  show('hello')
  expect(listed()).not.toContain('held')
  rendered.clear()
  show('hello again')
  expect([...rendered.keys()]).toEqual(['live-answer'])
  show('done', false)
  expect(listed()).toContain('held')
})

it.each([false, true])(
  'recovers held text and fences equal-preview replacement, grouped: %s',
  async (grouped) => {
    const target = grouped ? 'reason-0' : 'answer-0'
    const head = grouped ? 'tool-0' : target
    const short = grouped ? 'checking' : 'finished'
    const items = journal(2, 'hello').map((item) =>
      item.itemId === target ? { ...item, shortened: true as const } : item
    )
    let source: typeof itemSource | null = itemSource
    const show = (batch: AgentJournalRenderItem[]) =>
      showElement(createElement(Harness, { items: batch, source }))
    const answer = () =>
      renderer!.root.find(
        (node) => Object.is(node.type, 'ChatMessage') && node.props.message.id === head
      )
    const recovery = () => {
      if (!grouped) {
        return answer().props.recovery
      }
      const button = answer().findAll(
        (node) =>
          Object.is(node.type, 'Pressable') &&
          node.findAll(
            (child) => Object.is(child.type, 'Text') && child.children.includes('Show full message')
          ).length > 0
      )[0]
      return button
        ? { load: button.props.disabled ? 'loading' : 'idle', onPress: button.props.onPress }
        : null
    }
    const shown = () =>
      (grouped
        ? answer().props.workRun.find((member: NativeChatMessage) => member.id === target)
        : answer().props.message
      ).blocks[0].text
    const complete: AgentJournalRenderItem = {
      itemId: target,
      sequence: 4,
      observedAt: 4,
      revision: 2,
      body: textBody(grouped ? 'reasoning' : 'assistant', `${short} FULL TAIL`)
    }
    scroller.scrollHeight = 10000
    vi.useFakeTimers()
    show(items)
    act(() => renderer!.root.findByType(MobileNativeChatPageList).props.onEndDistance(200, true))
    act(() => {
      listeners.get('pointerdown')!()
      listeners.get('pointerup')!()
    })
    expect(recovery().load).toBe('idle')
    itemReads.mockResolvedValueOnce(complete)
    rendered.clear()
    await act(async () => {
      recovery().onPress()
    })
    expect(itemReads).toHaveBeenCalledOnce()
    expect(shown()).toBe(short)
    expect(recovery()).toBeNull()
    expect([...rendered.keys()]).toEqual(grouped ? [head, target] : [head])
    act(() => void vi.advanceTimersByTime(400))
    expect(shown()).toBe(`${short} FULL TAIL`)

    const replaced = items.map((item) => (item.itemId === target ? { ...item, revision: 3 } : item))
    show(replaced)
    const pending = Promise.withResolvers<AgentJournalRenderItem>()
    itemReads.mockReturnValueOnce(pending.promise)
    await act(async () => {
      recovery().onPress()
    })
    expect(recovery().load).toBe('loading')
    show(replaced.map((item) => (item.itemId === target ? { ...item, revision: 4 } : item)))
    expect(recovery().load).toBe('idle')
    await act(async () => {
      pending.resolve(complete)
      await pending.promise
    })
    expect(shown()).toBe(short)
    expect(recovery()).not.toBeNull()
    for (const next of [
      { ...itemSource, client: stubRpcClient() },
      { ...itemSource, sessionId: 'other' }
    ]) {
      act(() => {
        listeners.get('pointerdown')!()
        listeners.get('pointerup')!()
      })
      const old = Promise.withResolvers<AgentJournalRenderItem>()
      itemReads.mockReturnValueOnce(old.promise)
      await act(async () => recovery().onPress())
      const previous = source
      source = next
      show(items)
      expect(shown()).toBe(short)
      expect(recovery().load).toBe('idle')
      await act(async () => {
        old.resolve(complete)
        await old.promise
      })
      expect(recovery()).not.toBeNull()
      itemReads.mockResolvedValueOnce(complete)
      await act(async () => recovery().onPress())
      expect(
        itemReads.mock.calls.slice(-2).map((call) => [call[0].client, call[0].sessionId])
      ).toEqual([
        [previous!.client, previous!.sessionId],
        [next.client, next.sessionId]
      ])
      expect(recovery()).toBeNull()
      source = null
      show(items)
      expect(recovery()).toBeNull()
      act(() => void vi.advanceTimersByTime(400))
      source = next
      show(items)
    }
    show(items.filter((item) => item.itemId !== target))
    expect(
      renderer!.root.findAll(
        (node) => Object.is(node.type, 'ChatMessage') && node.props.message.id === target
      )
    ).toHaveLength(0)
  }
)

const clipped = (): NativeChatToolResultBlock => ({
  type: 'tool-result',
  fullOutputItemId: 'tool-item',
  output: 'same preview\n… (1000 bytes)'
})
const message = (id: string, body: NativeChatToolResultBlock): NativeChatMessage => ({
  id,
  role: 'assistant',
  source: 'transcript',
  timestamp: 1,
  blocks: [body]
})
it.each([false, true])(
  'fences replaced equal tool previews, nested work run: %s',
  async (nested) => {
    const pending = Promise.withResolvers<AgentJournalRenderItem | null>()
    itemReads.mockReturnValueOnce(pending.promise)
    const source = { ...itemSource, details: [], load: async () => {} }
    const head = message('head', { type: 'tool-result', output: 'head' })
    const replace = () => {
      const row = message('row', clipped())
      showElement(
        createElement(MobileNativeChatRowContent, {
          scope: 'chat',
          source,
          message: nested ? head : row,
          workRun: nested ? [row] : undefined
        })
      )
    }
    replace()
    const button = () => renderer!.root.find((node) => Object.is(node.type, 'Pressable'))
    act(() => button().props.onPress())
    expect(button().props.disabled).toBe(true)
    replace()
    expect(button().props.disabled).toBe(false)
    const fullOutput = (head: string): AgentJournalRenderItem => ({
      itemId: 'tool-item',
      revision: 1,
      sequence: 1,
      observedAt: 1,
      body: {
        kind: 'tool-call',
        name: 'Bash',
        input: {},
        state: 'completed',
        output: { head, byteLength: 1000, digest: 'fixture', truncated: false }
      }
    })
    await act(async () => {
      pending.resolve(fullOutput('old full output'))
      await pending.promise
    })
    expect(JSON.stringify(renderer!.toJSON())).not.toContain('old full output')
    itemReads.mockResolvedValueOnce(fullOutput('current full output'))
    await act(async () => button().props.onPress())
    expect(itemReads).toHaveBeenCalledTimes(2)
    expect(JSON.stringify(renderer!.toJSON())).toContain('current full output')
    replace()
    expect(JSON.stringify(renderer!.toJSON())).not.toContain('current full output')
  }
)