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.

31.0 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { connect } from './rpc-client'
import {
  encodeTerminalStreamFrame,
  TerminalStreamOpcode
} from '../../../src/shared/terminal-stream-protocol'

vi.mock('./direct-e2ee-framing-policy', () => import('./legacy-direct-framing-test-policy'))

vi.mock('./e2ee', () => ({
  generateKeyPair: () => ({
    publicKey: new Uint8Array(32),
    secretKey: new Uint8Array(32)
  }),
  deriveSharedKey: () => new Uint8Array(32),
  publicKeyFromBase64: () => new Uint8Array(32),
  publicKeyToBase64: () => 'client-public-key',
  encrypt: (plaintext: string) => `encrypted:${plaintext}`,
  decrypt: (raw: string) => (raw === 'undecryptable' ? null : raw.replace(/^encrypted:/, '')),
  decryptBytes: (bytes: Uint8Array) => bytes
}))

// Capability ordering has dedicated coverage; keep connection tests focused on socket behavior.
vi.mock('./mobile-runtime-capability-negotiation', () => ({
  negotiateMobileRuntimeCapabilities: (args: { onReady: () => void }) => args.onReady()
}))

class MockWebSocket {
  static CONNECTING = 0
  static OPEN = 1
  static CLOSING = 2
  static CLOSED = 3

  readonly CONNECTING = MockWebSocket.CONNECTING
  readonly OPEN = MockWebSocket.OPEN
  readonly CLOSING = MockWebSocket.CLOSING
  readonly CLOSED = MockWebSocket.CLOSED

  readyState = MockWebSocket.CONNECTING
  onopen: (() => void) | null = null
  onclose: (() => void) | null = null
  onmessage: ((event: { data: unknown }) => void) | null = null
  onerror: (() => void) | null = null
  emitCloseOnClose = true
  sent: string[] = []
  close = vi.fn(() => {
    if (this.readyState === MockWebSocket.CLOSED) {
      return
    }
    this.readyState = MockWebSocket.CLOSED
    if (this.emitCloseOnClose) {
      this.onclose?.()
    }
  })

  constructor(readonly endpoint: string) {
    mockSockets.push(this)
  }

  send(payload: string): void {
    this.sent.push(payload)
  }

  open(): void {
    this.readyState = MockWebSocket.OPEN
    this.onopen?.()
  }

  receive(payload: unknown): void {
    this.onmessage?.({ data: payload })
  }
}

const mockSockets: MockWebSocket[] = []
const originalWebSocket = globalThis.WebSocket

type SentRpcRequest = { id: string; method: string; params?: unknown }

function sentRequest(socket: MockWebSocket, method: string): SentRpcRequest {
  const request = sentRequests(socket, method)[0]
  if (request) {
    return request
  }
  throw new Error(`Request not sent: ${method}`)
}

function sentRequests(socket: MockWebSocket, method: string): SentRpcRequest[] {
  return socket.sent
    .map((payload) => {
      const request: unknown = JSON.parse(payload.replace(/^encrypted:/, ''))
      if (
        !request ||
        typeof request !== 'object' ||
        !('id' in request) ||
        typeof request.id !== 'string' ||
        !('method' in request) ||
        typeof request.method !== 'string'
      ) {
        return null
      }
      return request
    })
    .filter((request): request is SentRpcRequest => request !== null && request.method === method)
}

function encodeBrowserFrame(): Uint8Array {
  const metadata = new TextEncoder().encode(JSON.stringify({ deviceWidth: 800, deviceHeight: 600 }))
  const image = new Uint8Array([1, 2, 3, 4])
  const out = new Uint8Array(16 + metadata.byteLength + image.byteLength)
  const view = new DataView(out.buffer)
  view.setUint8(0, 0x62)
  view.setUint8(1, 1)
  view.setUint8(2, 1)
  view.setUint8(3, 1)
  view.setUint32(4, 7, true)
  view.setUint32(8, metadata.byteLength, true)
  view.setUint32(12, 0, true)
  out.set(metadata, 16)
  out.set(image, 16 + metadata.byteLength)
  return out
}

function encodeTerminalOutput(streamId: number, chunk: string): Uint8Array {
  return encodeTerminalStreamFrame({
    opcode: TerminalStreamOpcode.Output,
    streamId,
    seq: 1,
    payload: new TextEncoder().encode(chunk)
  })
}

function openAndAuthenticate(socket: MockWebSocket) {
  socket.open()
  socket.receive(JSON.stringify({ type: 'e2ee_ready' }))
  socket.receive('encrypted:{"type":"e2ee_authenticated"}')
}

describe('mobile rpc-client connection timeout', () => {
  beforeEach(() => {
    vi.useFakeTimers()
    mockSockets.length = 0
    globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket
  })

  afterEach(() => {
    vi.useRealTimers()
    globalThis.WebSocket = originalWebSocket
  })

  it('closes a socket that never opens so reconnect can run', () => {
    const states: string[] = []
    const client = connect('ws://desktop.invalid', 'token', 'server-key', (state) => {
      states.push(state)
    })

    expect(client.getState()).toBe('connecting')
    expect(mockSockets).toHaveLength(1)
    mockSockets[0]!.emitCloseOnClose = false

    vi.advanceTimersByTime(12_000)

    expect(mockSockets[0]!.close).toHaveBeenCalledTimes(1)
    expect(client.getState()).toBe('reconnecting')
    expect(states).toContain('reconnecting')

    client.close()
  })

  it('ignores stale socket opens after reconnect swaps in a new socket', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const firstSocket = mockSockets[0]!
    firstSocket.emitCloseOnClose = false

    vi.advanceTimersByTime(12_000)
    vi.advanceTimersByTime(500)

    const secondSocket = mockSockets[1]!
    expect(client.getState()).toBe('connecting')

    firstSocket.open()

    expect(client.getState()).toBe('connecting')
    expect(secondSocket.sent).toEqual([])

    vi.advanceTimersByTime(12_000)

    expect(secondSocket.close).toHaveBeenCalledTimes(1)

    client.close()
  })

  it('clears the open timeout once the socket opens and authenticates', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    expect(client.getState()).toBe('connected')

    vi.advanceTimersByTime(12_000)

    expect(socket.close).not.toHaveBeenCalled()
    expect(client.getState()).toBe('connected')

    client.close()
  })

  it('sends session tabs unsubscribe when a session tab stream is disposed', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    const unsubscribe = client.subscribe(
      'session.tabs.subscribe',
      { worktree: 'id:wt-1' },
      () => {}
    )
    const request = sentRequest(socket, 'session.tabs.subscribe')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: request.id,
        ok: true,
        streaming: true,
        result: { type: 'snapshot', worktree: 'id:wt-1', tabs: [] },
        _meta: { runtimeId: 'r1' }
      })}`
    )
    unsubscribe()

    expect(sentRequests(socket, 'session.tabs.unsubscribe')).toEqual([
      expect.objectContaining({ params: { worktree: 'id:wt-1', subscriptionId: request.id } })
    ])

    client.close()
  })

  it('does not resend a stream subscribed from the connected-state listener', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key', (state) => {
      if (state === 'connected') {
        client.subscribe('notifications.subscribe', {}, () => {})
      }
    })
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    expect(sentRequests(socket, 'notifications.subscribe')).toHaveLength(1)

    client.close()
  })

  it('routes browser screencast binary frames to the browser subscriber', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!
    const frames: unknown[] = []

    openAndAuthenticate(socket)

    const unsubscribe = client.subscribe(
      'browser.screencast',
      { worktree: 'id:wt-1', page: 'page-1' },
      () => {},
      { onBinaryFrame: (frame) => frames.push(frame) }
    )
    const request = sentRequest(socket, 'browser.screencast')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: request.id,
        ok: true,
        streaming: true,
        result: { type: 'ready', subscriptionId: 'browser-screencast:page-1:test' },
        _meta: { runtimeId: 'r1' }
      })}`
    )

    client.notifyForeground()
    socket.receive(encodeBrowserFrame())
    await Promise.resolve()
    await Promise.resolve()
    await vi.advanceTimersByTimeAsync(8_000)

    expect(frames).toHaveLength(1)
    expect(socket.close).not.toHaveBeenCalled()
    expect(frames[0]).toMatchObject({
      seq: 7,
      format: 'jpeg',
      metadata: { deviceWidth: 800, deviceHeight: 600 }
    })

    unsubscribe()
    client.close()
  })

  it('sends browser screencast unsubscribe after ready even when disposed early', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    const unsubscribe = client.subscribe(
      'browser.screencast',
      { worktree: 'id:wt-1', page: 'page-1' },
      () => {},
      { onBinaryFrame: () => {} }
    )
    const request = sentRequest(socket, 'browser.screencast')
    unsubscribe()
    socket.receive(
      `encrypted:${JSON.stringify({
        id: request.id,
        ok: true,
        streaming: true,
        result: { type: 'ready', subscriptionId: 'browser-screencast:page-1:test' },
        _meta: { runtimeId: 'r1' }
      })}`
    )

    expect(
      socket.sent.some(
        (payload) =>
          payload.includes('"method":"browser.screencast.unsubscribe"') &&
          payload.includes('"subscriptionId":"browser-screencast:page-1:test"')
      )
    ).toBe(true)

    client.close()
  })

  it('reports rejected browser screencast subscribes and drops the stale frame sink', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!
    const events: unknown[] = []
    const frames: unknown[] = []

    openAndAuthenticate(socket)

    client.subscribe(
      'browser.screencast',
      { worktree: 'id:wt-1', page: 'page-1' },
      (event) => events.push(event),
      { onBinaryFrame: (frame) => frames.push(frame) }
    )
    const request = sentRequest(socket, 'browser.screencast')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: request.id,
        ok: false,
        error: { code: 'forbidden', message: 'not allowed' },
        _meta: { runtimeId: 'r1' }
      })}`
    )

    socket.receive(encodeBrowserFrame())
    await Promise.resolve()
    await Promise.resolve()

    expect(events).toEqual([
      {
        type: 'error',
        message: 'not allowed',
        error: { code: 'forbidden', message: 'not allowed' }
      }
    ])
    expect(frames).toHaveLength(0)

    client.close()
  })

  it('deletes queued browser screencast subscribes when disposed before connect', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    const unsubscribe = client.subscribe(
      'browser.screencast',
      { worktree: 'id:wt-1', page: 'page-1' },
      () => {},
      { onBinaryFrame: () => {} }
    )
    unsubscribe()

    openAndAuthenticate(socket)

    expect(sentRequests(socket, 'browser.screencast')).toHaveLength(0)

    client.close()
  })

  it('replaces duplicate browser screencast subscribers and unsubscribes the old stream', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    client.subscribe('browser.screencast', { worktree: 'id:wt-1', page: 'page-1' }, () => {}, {
      onBinaryFrame: () => {}
    })
    const first = sentRequest(socket, 'browser.screencast')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: first.id,
        ok: true,
        streaming: true,
        result: { type: 'ready', subscriptionId: 'browser-screencast:page-1:first' },
        _meta: { runtimeId: 'r1' }
      })}`
    )

    client.subscribe('browser.screencast', { worktree: 'id:wt-1', page: 'page-2' }, () => {}, {
      onBinaryFrame: () => {}
    })

    expect(sentRequests(socket, 'browser.screencast')).toHaveLength(2)
    expect(
      socket.sent.some(
        (payload) =>
          payload.includes('"method":"browser.screencast.unsubscribe"') &&
          payload.includes('"subscriptionId":"browser-screencast:page-1:first"')
      )
    ).toBe(true)

    client.close()
  })

  it('drops old browser frames while a replacement stream is waiting for ready', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!
    const firstFrames: unknown[] = []
    const secondFrames: unknown[] = []

    openAndAuthenticate(socket)

    client.subscribe('browser.screencast', { worktree: 'id:wt-1', page: 'page-1' }, () => {}, {
      onBinaryFrame: (frame) => firstFrames.push(frame)
    })
    const first = sentRequest(socket, 'browser.screencast')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: first.id,
        ok: true,
        streaming: true,
        result: { type: 'ready', subscriptionId: 'browser-screencast:page-1:first' },
        _meta: { runtimeId: 'r1' }
      })}`
    )

    client.subscribe('browser.screencast', { worktree: 'id:wt-1', page: 'page-2' }, () => {}, {
      onBinaryFrame: (frame) => secondFrames.push(frame)
    })
    const browserRequests = sentRequests(socket, 'browser.screencast')
    const second = browserRequests[browserRequests.length - 1]!
    socket.receive(encodeBrowserFrame())
    await Promise.resolve()
    await Promise.resolve()

    socket.receive(
      `encrypted:${JSON.stringify({
        id: second.id,
        ok: true,
        streaming: true,
        result: { type: 'ready', subscriptionId: 'browser-screencast:page-2:second' },
        _meta: { runtimeId: 'r1' }
      })}`
    )
    socket.receive(encodeBrowserFrame())
    await Promise.resolve()
    await Promise.resolve()

    expect(firstFrames).toHaveLength(0)
    expect(secondFrames).toHaveLength(1)

    client.close()
  })

  it('still routes terminal binary frames after browser demux is enabled', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!
    const events: unknown[] = []

    openAndAuthenticate(socket)

    client.subscribe('terminal.subscribe', { terminal: 'term-1' }, (event) => events.push(event))
    const request = sentRequest(socket, 'terminal.subscribe')
    socket.receive(
      `encrypted:${JSON.stringify({
        id: request.id,
        ok: true,
        streaming: true,
        result: { type: 'subscribed', streamId: 42 },
        _meta: { runtimeId: 'r1' }
      })}`
    )
    socket.receive(encodeTerminalOutput(42, 'hello'))
    await Promise.resolve()
    await Promise.resolve()

    expect(events).toContainEqual({ type: 'data', streamId: 42, chunk: 'hello' })

    client.close()
  })

  it('replays terminal subscribe with the latest viewport after reconnect', () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const firstSocket = mockSockets[0]!

    openAndAuthenticate(firstSocket)

    client.subscribe(
      'terminal.subscribe',
      {
        terminal: 'term-1',
        client: { id: 'phone-1', type: 'mobile' },
        viewport: { cols: 45, rows: 20 }
      },
      () => {}
    )
    expect(sentRequest(firstSocket, 'terminal.subscribe').params).toMatchObject({
      viewport: { cols: 45, rows: 20 }
    })

    client.updateTerminalSubscriptionViewport('term-1', { cols: 60, rows: 24 })
    firstSocket.close()
    vi.advanceTimersByTime(500)
    const secondSocket = mockSockets[1]!
    openAndAuthenticate(secondSocket)

    expect(sentRequest(secondSocket, 'terminal.subscribe').params).toMatchObject({
      viewport: { cols: 60, rows: 24 }
    })

    client.close()
  })

  it('honors per-request timeout overrides', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)

    const request = client.sendRequest(
      'speech.dictation.finish',
      { dictationId: 'd1' },
      {
        timeoutMs: 123
      }
    )
    let settled = false
    const outcome = request.then(
      (response) => {
        settled = true
        return response
      },
      (error: unknown) => {
        settled = true
        return error
      }
    )
    await Promise.resolve()
    expect(sentRequest(socket, 'speech.dictation.finish').params).toEqual({ dictationId: 'd1' })

    await vi.advanceTimersByTimeAsync(122)
    expect(settled).toBe(false)

    await vi.advanceTimersByTimeAsync(1)
    const error = await outcome
    if (!(error instanceof Error)) {
      throw new Error('Expected the request timeout')
    }
    expect(error.message).toBe('Request timed out: speech.dictation.finish')

    client.close()
  })

  it('applies per-request timeout overrides while waiting for reconnect', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)
    socket.close()

    const request = client.sendRequest(
      'speech.dictation.finish',
      { dictationId: 'd1' },
      {
        timeoutMs: 123
      }
    )
    let requestOutcome = 'pending'
    request.then(
      () => {
        requestOutcome = 'resolved'
      },
      (error: Error) => {
        requestOutcome = error.message
      }
    )

    try {
      await vi.advanceTimersByTimeAsync(122)
      await Promise.resolve()
      expect(requestOutcome).toBe('pending')

      await vi.advanceTimersByTimeAsync(1)
      await Promise.resolve()
      expect(requestOutcome).toBe('Timed out while connecting to the remote Orca runtime.')
    } finally {
      client.close()
      await request.catch(() => undefined)
    }
  })

  // Foreground recovery must heal Android sessions left half-open after suspension (#5049).
  describe('foreground recovery', () => {
    function connectAuthenticated() {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      const socket = mockSockets[0]!
      openAndAuthenticate(socket)
      return { client, socket }
    }

    // Pass the fast-attempt cap: 360.5s backoff + 13 × 12s connect timeouts, leaving the first trickle timer armed.
    const PAST_GIVE_UP_CAP_MS = 520_000

    it('keeps trickle-retrying after the give-up cap instead of parking', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      openAndAuthenticate(mockSockets[0]!)
      mockSockets[0]!.close()

      await vi.advanceTimersByTimeAsync(PAST_GIVE_UP_CAP_MS)
      expect(client.getState()).toBe('reconnecting')
      expect(client.getReconnectAttempt()).toBeGreaterThanOrEqual(12)

      // A wedged VPN sends no revival nudge, so retry autonomously at trickle cadence (#7824).
      const socketsBefore = mockSockets.length
      await vi.advanceTimersByTimeAsync(102_000)
      expect(mockSockets.length).toBeGreaterThan(socketsBefore)

      // 75s reaches the next dial’s 12s connect window after the previous dial re-armed the 90s trickle.
      await vi.advanceTimersByTimeAsync(75_000)
      openAndAuthenticate(mockSockets[mockSockets.length - 1]!)
      expect(client.getState()).toBe('connected')
      expect(client.getReconnectAttempt()).toBe(0)

      client.close()
    })

    it('restarts a backed-off reconnect loop on foreground without waiting out the trickle', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      openAndAuthenticate(mockSockets[0]!)
      mockSockets[0]!.close()
      await vi.advanceTimersByTimeAsync(PAST_GIVE_UP_CAP_MS)
      expect(client.getReconnectAttempt()).toBe(12)

      const socketsBefore = mockSockets.length
      client.notifyForeground()

      expect(mockSockets.length).toBe(socketsBefore + 1)
      expect(client.getReconnectAttempt()).toBe(0)
      openAndAuthenticate(mockSockets[mockSockets.length - 1]!)
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('fast-forwards a pending backoff timer on foreground', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      openAndAuthenticate(mockSockets[0]!)
      mockSockets[0]!.close()
      expect(client.getState()).toBe('reconnecting')

      const socketsBefore = mockSockets.length
      client.notifyForeground()

      expect(mockSockets.length).toBe(socketsBefore + 1)
      openAndAuthenticate(mockSockets[mockSockets.length - 1]!)
      expect(client.getState()).toBe('connected')

      await vi.advanceTimersByTimeAsync(1_000)
      expect(mockSockets.length).toBe(socketsBefore + 1)

      client.close()
    })

    it('reaps a half-open socket after three fair foreground probe windows', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      const socket = mockSockets[0]!
      openAndAuthenticate(socket)

      // Half-open: readyState stays OPEN but the server never answers.
      client.notifyForeground()
      expect(sentRequests(socket, 'status.get')).toHaveLength(1)

      await vi.advanceTimersByTimeAsync(24_000)
      expect(socket.close).toHaveBeenCalled()

      await vi.advanceTimersByTimeAsync(500)
      openAndAuthenticate(mockSockets[mockSockets.length - 1]!)
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('reconnects when the half-open socket omits its close callback', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      const socket = mockSockets[0]!
      openAndAuthenticate(socket)
      socket.emitCloseOnClose = false

      client.notifyForeground()
      await vi.advanceTimersByTimeAsync(24_000)

      expect(socket.close).toHaveBeenCalledTimes(1)
      socket.onclose?.()
      expect(client.getState()).toBe('reconnecting')

      await vi.advanceTimersByTimeAsync(500)
      expect(mockSockets).toHaveLength(2)
      openAndAuthenticate(mockSockets[1]!)
      expect(client.getState()).toBe('connected')
      expect(client.getReconnectAttempt()).toBe(0)

      await vi.advanceTimersByTimeAsync(1_000)
      expect(mockSockets).toHaveLength(2)

      client.close()
    })

    it('coalesces repeated foreground probes while one probe is pending', async () => {
      const client = connectAuthenticated().client
      const socket = mockSockets[0]!
      client.notifyForeground()
      client.notifyForeground()
      client.notifyForeground()
      expect(sentRequests(socket, 'status.get')).toHaveLength(1)
      await vi.advanceTimersByTimeAsync(24_000)
      expect(sentRequests(socket, 'status.get')).toHaveLength(3)
      expect(socket.close).toHaveBeenCalledTimes(1)
      expect(client.getState()).toBe('reconnecting')

      await vi.advanceTimersByTimeAsync(500)
      expect(mockSockets).toHaveLength(2)
      client.close()
    })

    it('keeps a healthy connection when the foreground probe is answered', async () => {
      const { client, socket } = connectAuthenticated()

      client.notifyForeground()
      const probe = sentRequest(socket, 'status.get')
      socket.receive(`encrypted:${JSON.stringify({ id: probe.id, ok: true, result: {} })}`)

      await vi.advanceTimersByTimeAsync(24_000)
      expect(socket.close).not.toHaveBeenCalled()
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('keeps a healthy connection when another response arrives while the probe is pending', async () => {
      const { client, socket } = connectAuthenticated()

      client.notifyForeground()
      expect(sentRequests(socket, 'status.get')).toHaveLength(1)

      const poll = client.sendRequest('speech.models.list')
      await Promise.resolve()
      const pollRequest = sentRequest(socket, 'speech.models.list')
      socket.receive(
        `encrypted:${JSON.stringify({
          id: pollRequest.id,
          ok: true,
          result: { enabled: false, selectedModelId: '', dictationMode: 'toggle', models: [] }
        })}`
      )
      await expect(poll).resolves.toMatchObject({ ok: true })

      await vi.advanceTimersByTimeAsync(8_000)
      expect(socket.close).not.toHaveBeenCalled()

      await vi.advanceTimersByTimeAsync(12_000)
      expect(sentRequests(socket, 'status.get')).toHaveLength(2)
      await vi.advanceTimersByTimeAsync(7_999)
      expect(socket.close).not.toHaveBeenCalled()
      await vi.advanceTimersByTimeAsync(1)
      expect(socket.close).not.toHaveBeenCalled()
      await vi.advanceTimersByTimeAsync(16_000)
      expect(socket.close).toHaveBeenCalled()
      expect(client.getState()).toBe('reconnecting')

      client.close()
    })

    it('keeps a healthy connection when a non-auth RPC failure arrives while the probe is pending', async () => {
      const { client, socket } = connectAuthenticated()

      client.notifyForeground()
      expect(sentRequests(socket, 'status.get')).toHaveLength(1)

      const poll = client.sendRequest('speech.models.list')
      await Promise.resolve()
      const pollRequest = sentRequest(socket, 'speech.models.list')
      socket.receive(
        `encrypted:${JSON.stringify({
          id: pollRequest.id,
          ok: false,
          error: { code: 'download_failed', message: 'model download failed' }
        })}`
      )
      await expect(poll).resolves.toMatchObject({
        ok: false,
        error: { code: 'download_failed' }
      })

      await vi.advanceTimersByTimeAsync(24_000)
      expect(socket.close).not.toHaveBeenCalled()
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('keeps a healthy connection when a binary stream frame arrives while the probe is pending', async () => {
      const { client, socket } = connectAuthenticated()
      const events: unknown[] = []

      client.subscribe('terminal.subscribe', { terminal: 'term-1' }, (event) => {
        events.push(event)
      })
      const subscribe = sentRequest(socket, 'terminal.subscribe')
      socket.receive(
        `encrypted:${JSON.stringify({
          id: subscribe.id,
          ok: true,
          streaming: true,
          result: { type: 'subscribed', streamId: 42 }
        })}`
      )

      client.notifyForeground()
      socket.receive(encodeTerminalOutput(42, 'still alive'))
      await Promise.resolve()
      await Promise.resolve()
      await vi.advanceTimersByTimeAsync(24_000)

      expect(events).toContainEqual({ type: 'data', streamId: 42, chunk: 'still alive' })
      expect(socket.close).not.toHaveBeenCalled()
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('counts authenticated unknown payloads before semantic decoding', async () => {
      for (const payload of [
        'encrypted:{"unexpected":true}',
        'encrypted:{"id":"rpc-incomplete","ok":true}',
        new Uint8Array([0xff, 0x00, 0x01])
      ]) {
        const client = connect('ws://desktop.invalid', 'token', 'server-key')
        const socket = mockSockets.at(-1)!
        openAndAuthenticate(socket)
        client.notifyForeground()
        socket.receive(payload)

        await vi.advanceTimersByTimeAsync(24_000)
        expect(socket.close).not.toHaveBeenCalled()
        expect(client.getState()).toBe('connected')

        client.close()
      }
    })

    it('does not count undecryptable payloads as probe activity', async () => {
      const { client, socket } = connectAuthenticated()

      client.notifyForeground()
      socket.receive('undecryptable')

      await vi.advanceTimersByTimeAsync(24_000)
      expect(socket.close).toHaveBeenCalled()

      client.close()
    })

    it('is a no-op after the client is closed', () => {
      const { client } = connectAuthenticated()
      client.close()

      const socketsBefore = mockSockets.length
      client.notifyForeground()
      expect(mockSockets.length).toBe(socketsBefore)
      expect(client.getState()).toBe('disconnected')
    })
  })

  // Transient auth rejection must not force re-pairing while the desktop still has valid credentials (#5200).
  describe('auth rejection retry (issue #5200)', () => {
    function unauthorizedResponsePayload(id: string): string {
      return `encrypted:${JSON.stringify({ id, ok: false, error: { code: 'unauthorized', message: 'Unauthorized' } })}`
    }

    it('retries the handshake on a transient e2ee_error instead of latching auth-failed', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')
      const first = mockSockets[0]!
      first.open()
      first.receive(JSON.stringify({ type: 'e2ee_ready' }))

      first.receive('encrypted:{"type":"e2ee_error","error":{"code":"unauthorized"}}')
      expect(client.getState()).toBe('reconnecting')

      await vi.advanceTimersByTimeAsync(500)
      openAndAuthenticate(mockSockets.at(-1)!)
      expect(client.getState()).toBe('connected')

      client.close()
    })

    it('latches auth-failed once the retry budget is exhausted', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')

      // Allow cycle 2’s larger RECONNECT_DELAYS[1] after failed handshakes (#10119).
      for (let i = 0; i < 3; i++) {
        if (i > 0) {
          await vi.advanceTimersByTimeAsync(1_000)
        }
        const socket = mockSockets[mockSockets.length - 1]!
        socket.open()
        socket.receive(JSON.stringify({ type: 'e2ee_ready' }))
        socket.receive('encrypted:{"type":"e2ee_error","error":{"code":"unauthorized"}}')
      }

      expect(client.getState()).toBe('auth-failed')

      client.close()
    })

    it('resets the budget after a successful connect between rejections', async () => {
      const client = connect('ws://desktop.invalid', 'token', 'server-key')

      // Allow growing handshake backoff before the successful reset (#10119).
      for (let i = 0; i < 2; i++) {
        if (i > 0) {
          await vi.advanceTimersByTimeAsync(1_000)
        }
        const socket = mockSockets[mockSockets.length - 1]!
        socket.open()
        socket.receive(JSON.stringify({ type: 'e2ee_ready' }))
        socket.receive('encrypted:{"type":"e2ee_error","error":{"code":"unauthorized"}}')
      }
      await vi.advanceTimersByTimeAsync(1_000)
      openAndAuthenticate(mockSockets.at(-1)!)
      expect(client.getState()).toBe('connected')

      const live = mockSockets[mockSockets.length - 1]!
      const request = client.sendRequest('status.get').catch(() => undefined)
      // Let sendRequest’s connect wait flush before inspecting the frame.
      await Promise.resolve()
      const id = sentRequest(live, 'status.get').id
      live.receive(unauthorizedResponsePayload(id))
      await request
      expect(client.getState()).toBe('reconnecting')

      client.close()
    })
  })

  it('rejects requests waiting for reconnect after the retry cap', async () => {
    const client = connect('ws://desktop.invalid', 'token', 'server-key')
    const socket = mockSockets[0]!

    openAndAuthenticate(socket)
    socket.close()

    const waitingRequestError = client.sendRequest('status.get').then(
      () => null,
      (error: Error) => error
    )
    await vi.advanceTimersByTimeAsync(520_000)

    expect(client.getState()).toBe('reconnecting')
    expect(client.getReconnectAttempt()).toBe(12)
    await expect(waitingRequestError).resolves.toMatchObject({
      message: 'Connection retry limit reached'
    })
    await expect(client.sendRequest('status.get')).rejects.toThrow('Connection retry limit reached')

    client.close()
  })
})