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.

6.8 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { isRpcDeliveryUnknown } from '../../transport/rpc-delivery-ambiguity'
import { BRIDGE_MAX_MESSAGE_BYTES } from './bridge-caps'
import { BRIDGE_PROTOCOL_VERSION } from './bridge-envelope'
import { createPageClient as createPage, idOf, readError } from './bridge-page-client-test-harness'

const resources = new Set<ReturnType<typeof createPage>>()
function createPageClient(...args: Parameters<typeof createPage>): ReturnType<typeof createPage> {
  const resource = createPage(...args)
  resources.add(resource)
  return resource
}
function closeResources(): void {
  for (const resource of resources) {
    resource.client.close()
  }
  resources.clear()
}

beforeEach(() => {
  vi.useFakeTimers()
})

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

describe('bridge client refusals and send failures', () => {
  it('reports a frame its own reader will not take, and changes nothing', () => {
    const page = createPageClient()
    page.start()
    page.deliverRaw('{ not json')
    page.deliverRaw(JSON.stringify({ v: 99, type: 'state' }))
    page.deliverRaw(`"${'z'.repeat(BRIDGE_MAX_MESSAGE_BYTES)}"`)
    expect(page.diagnostics).toEqual([
      { kind: 'refused', refusal: 'malformed-json' },
      { kind: 'refused', refusal: 'unrecognised-message' },
      { kind: 'refused', refusal: 'oversized' }
    ])
    expect(page.client.getState()).toBe('connected')
  })

  it('settles the request a reply it could not read was answering, on the same turn', async () => {
    const page = createPageClient()
    page.start()
    const answer = page.client.sendRequest('worktree.ps')
    // `{ ok: true }` with no `result`: refused by this reader and by `isRpcResponse` alike.
    page.deliver({
      v: BRIDGE_PROTOCOL_VERSION,
      type: 'reply',
      id: idOf(page, 0),
      payload: { id: 'frame-1', ok: true }
    })
    // Settle immediately; waiting for a timer lets consumers render without their answer.
    const error = await answer.catch((thrown: unknown) => thrown)
    expect(readError(error).name).toBe('BridgeReplyRefusedError')
    expect(readError(error).message).toContain('unrecognised-message')
    expect(isRpcDeliveryUnknown(error)).toBe(true)
    expect(page.diagnostics).toContainEqual({
      kind: 'refused',
      refusal: 'unrecognised-message'
    })
  })

  it('ends the stream an event it could not read belonged to, and cancels it at the shell', () => {
    const page = createPageClient()
    page.start()
    const ended: unknown[] = []
    page.client.subscribe('terminal.stream', { terminal: 't1' }, (result) => {
      ended.push(result)
    })
    page.deliver({ v: BRIDGE_PROTOCOL_VERSION, type: 'event', id: idOf(page, 0), seq: -1 })
    expect(page.diagnostics.map((diagnostic) => diagnostic.kind)).toEqual([
      'refused',
      'stream-failed'
    ])
    expect(ended).toHaveLength(1)
    // Cancel at the shell too: its unacked-frame backstop never releases a stream that has gone quiet.
    expect(page.frames().at(-1)).toEqual({
      v: BRIDGE_PROTOCOL_VERSION,
      type: 'cancel',
      id: idOf(page, 0),
      target: 'subscription'
    })
  })

  it('settles distinct retired streams without posting cancel', () => {
    const page = createPageClient()
    page.start()
    const ended: unknown[] = []
    const failed: unknown[] = []
    page.client.subscribe('terminal.stream', { terminal: 't1' }, (value) => ended.push(value))
    page.client.subscribe('terminal.stream', { terminal: 't2' }, (value) => failed.push(value))
    const end = { v: BRIDGE_PROTOCOL_VERSION, type: 'end', id: idOf(page, 0), reason: 'closed' }
    const error = {
      v: BRIDGE_PROTOCOL_VERSION,
      type: 'error',
      id: idOf(page, 1),
      error: { category: 'Error', message: 'gone', isRpcDeliveryUnknown: false }
    }
    const before = page.frames().length
    page.deliver(end)
    page.deliver(error)
    expect(ended).toEqual([
      expect.objectContaining({ type: 'error', message: expect.stringContaining('closed') })
    ])
    expect(failed).toEqual([expect.objectContaining({ type: 'error', message: 'gone' })])
    page.deliver(end)
    page.deliver(error)
    expect(ended).toHaveLength(1)
    expect(failed).toHaveLength(1)
    expect(page.frames()).toHaveLength(before)
    expect(page.diagnostics.filter((entry) => entry.kind === 'refused')).toEqual([])
  })

  it('cannot settle a reply whose frame it never parsed, and nothing on the page can', async () => {
    const page = createPageClient()
    page.start()
    const answer = page.client.sendRequest('worktree.ps')
    let settled = false
    void answer.then(
      () => {
        settled = true
      },
      () => {
        settled = true
      }
    )
    // Oversized/malformed JSON yields no salvageable id; only close/replacement can release its exchange. A conforming host instead chunks or sends an error within caps.
    page.deliverRaw(`{"v":1,"type":"reply","id":"${idOf(page, 0)}",`)
    page.deliverRaw(`"${'z'.repeat(BRIDGE_MAX_MESSAGE_BYTES)}"`)
    await Promise.resolve()
    expect(page.diagnostics).toEqual([
      { kind: 'refused', refusal: 'malformed-json' },
      { kind: 'refused', refusal: 'oversized' }
    ])
    expect(settled).toBe(false)
    page.client.close()
    const error = await answer.catch((thrown: unknown) => thrown)
    expect(readError(error).name).toBe('BridgeClientClosedError')
    expect(isRpcDeliveryUnknown(error)).toBe(true)
  })

  it('leaves a refused frame that names no open exchange to the diagnostic alone', async () => {
    const page = createPageClient()
    page.start()
    const answer = page.client.sendRequest('worktree.ps')
    page.deliver({
      v: BRIDGE_PROTOCOL_VERSION,
      type: 'reply',
      id: 'ZZZZZZZZZZZZZZZZZZZZZZ',
      payload: { id: 'frame-1', ok: true }
    })
    expect(page.diagnostics).toEqual([{ kind: 'refused', refusal: 'unrecognised-message' }])
    page.deliver({
      v: BRIDGE_PROTOCOL_VERSION,
      type: 'reply',
      id: idOf(page, 0),
      payload: { id: 'frame-1', ok: true, result: 7, _meta: { runtimeId: 'runtime-a' } }
    })
    await expect(answer).resolves.toEqual({
      id: 'frame-1',
      ok: true,
      result: 7,
      _meta: { runtimeId: 'runtime-a' }
    })
  })

  it('fails a request whose frame never left the page, without the delivery mark', async () => {
    let live = true
    const page = createPageClient({
      send: () => {
        if (!live) {
          throw new Error('the port is gone')
        }
      }
    })
    page.start()
    live = false
    const answer = page.client.sendRequest('worktree.ps')
    const error = await answer.catch((thrown: unknown) => thrown)
    expect(readError(error).name).toBe('BridgeSendFailedError')
    expect(isRpcDeliveryUnknown(error)).toBe(false)
    expect(page.diagnostics.at(-1)).toEqual({
      kind: 'send-failed',
      error: expect.any(Error)
    })
  })
})