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.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
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()
})
})