509 lines
24 KiB
TypeScript
509 lines
24 KiB
TypeScript
vi.mock('expo', () => ({ requireOptionalNativeModule: () => undefined }))
|
|
import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs'
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import type { AdaptiveTransportOptions } from '@dsh-remote/webrtc'
|
|
|
|
class FakeCore {
|
|
private readonly closeHandlers = new Set<() => void>()
|
|
private readonly eventHandlers = new Set<(event: unknown) => void>()
|
|
readonly rpcCalls: Array<{ method: string; params?: unknown }> = []
|
|
|
|
async connect(): Promise<void> { await testState.connectGate?.() }
|
|
|
|
async rpc(method: string, params?: unknown): Promise<unknown> {
|
|
this.rpcCalls.push({ method, params })
|
|
if (method === 'harness.transport.describe') return { capabilities: testState.capabilities,
|
|
...(testState.workspaceTypes === undefined ? {} : { workspaceTypes: testState.workspaceTypes }) }
|
|
if (method === 'harness.remote.stream.open') return {}
|
|
if (method === 'harness.remote.stream.close') return {}
|
|
if (method === 'harness.remote.call') {
|
|
const request = params as { endpoint?: string }
|
|
if (request.endpoint === 'commands/execute') {
|
|
return { ok: true, value: { commandId: 'permission', result: { kind: 'success' } } }
|
|
}
|
|
return { ok: true, value: undefined }
|
|
}
|
|
return {}
|
|
}
|
|
|
|
onEvent(handler: (event: unknown) => void): () => void {
|
|
this.eventHandlers.add(handler)
|
|
return () => this.eventHandlers.delete(handler)
|
|
}
|
|
|
|
onClose(handler: () => void): () => void {
|
|
this.closeHandlers.add(handler)
|
|
return () => this.closeHandlers.delete(handler)
|
|
}
|
|
|
|
emit(event: unknown): void {
|
|
for (const handler of this.eventHandlers) handler(event)
|
|
}
|
|
|
|
getStats() { return { mode: 'Relay', connected: true } }
|
|
|
|
async close(): Promise<void> {
|
|
for (const handler of this.closeHandlers) handler()
|
|
}
|
|
}
|
|
|
|
const testState = vi.hoisted(() => ({
|
|
capabilities: ['harness.remote.v1'] as string[],
|
|
workspaceTypes: undefined as unknown,
|
|
cores: [] as FakeCore[],
|
|
connectGate: undefined as undefined | (() => Promise<void>),
|
|
transportOptions: [] as AdaptiveTransportOptions[],
|
|
}))
|
|
|
|
vi.mock('@dsh-remote/client-core', async () => {
|
|
const actual = await vi.importActual<typeof import('@dsh-remote/client-core')>('@dsh-remote/client-core')
|
|
return {
|
|
...actual,
|
|
RemoteClientCore: class {
|
|
constructor() {
|
|
const core = new FakeCore()
|
|
testState.cores.push(core)
|
|
return core
|
|
}
|
|
},
|
|
}
|
|
})
|
|
|
|
vi.mock('@dsh-remote/webrtc', () => ({ AdaptiveTransport: class {
|
|
constructor(_url: string, options: AdaptiveTransportOptions) { testState.transportOptions.push(options) }
|
|
} }))
|
|
vi.mock('../src/services/secure-transport', () => ({ SecureTransport: class {} }))
|
|
|
|
import { AndroidRemoteConnection } from '../src/services/connection'
|
|
import type { DeviceIdentity, RemoteDevice } from '../src/types'
|
|
|
|
const identity: DeviceIdentity = {
|
|
deviceId: 'client-1',
|
|
name: 'Android',
|
|
platform: 'android',
|
|
publicKey: 'client-public',
|
|
privateKey: 'client-private',
|
|
}
|
|
|
|
const host: RemoteDevice = {
|
|
deviceId: 'host-1',
|
|
name: 'Host',
|
|
platform: 'darwin',
|
|
identityKey: 'host-public',
|
|
membershipId: 'membership-1',
|
|
online: true,
|
|
trusted: true,
|
|
}
|
|
|
|
describe('AndroidRemoteConnection Harness transport selection', () => {
|
|
const prepareScenario1 = () => {
|
|
testState.capabilities = ['harness.remote.v1']
|
|
testState.workspaceTypes = undefined
|
|
testState.cores.length = 0
|
|
testState.connectGate = undefined
|
|
testState.transportOptions.length = 0
|
|
}
|
|
beforeEach(prepareScenario1)
|
|
afterEach(async () => {
|
|
await Promise.all(testState.cores.map(core => core.close()))
|
|
vi.useRealTimers()
|
|
})
|
|
|
|
it('scopes binary upload support to the current Host and clears it on close', async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
for (const binary of [false, true, false]) {
|
|
testState.capabilities = ['harness.remote.v1', 'workspace.upload.v1', ...(binary ? ['workspace.upload.binary.v1'] : [])]
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)
|
|
expect(connection.supportsBinaryUpload()).toBe(binary)
|
|
}
|
|
await connection.close()
|
|
expect(connection.supportsBinaryUpload()).toBe(false)
|
|
})
|
|
|
|
it('gives TURN-only attempts an allocation budget without slowing automatic routing', async () => {
|
|
await runScenarios([
|
|
{ name: 'automatic', preferred: ['lan', 'p2p', 'turn', 'relay'] as const, timeout: 6000 },
|
|
{ name: 'TURN', preferred: ['turn', 'relay'] as const, timeout: 12000 },
|
|
{ name: 'forced Relay', preferred: ['turn', 'relay'] as const, forceRelay: true, timeout: 6000 },
|
|
{ name: 'default automatic', preferred: undefined, timeout: 6000 },
|
|
].map(row => ({ name: row.name, run: async () => {
|
|
prepareScenario1()
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, {
|
|
preferredTransports: row.preferred === undefined ? undefined : [...row.preferred],
|
|
forceRelay: 'forceRelay' in row ? row.forceRelay : false,
|
|
})
|
|
expect(testState.transportOptions[0]?.negotiateTimeoutMs).toBe(row.timeout)
|
|
await connection.close()
|
|
} })))
|
|
})
|
|
|
|
it('uses the native Typert attachment contract and rejects late images from retired connections', async () => {
|
|
await runScenarios(['direct', 'business-result', 'denied', 'disconnected', 'cancelled'].map(mode => ({ name: mode, run: async () => {
|
|
prepareScenario1()
|
|
testState.capabilities = ['harness.remote.v1', 'harness.remote.transfer.v1']
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)
|
|
const core = testState.cores[0]!
|
|
const controller = new AbortController()
|
|
const attachment = { attachmentId: 'a1', mediaType: 'image/png', bytes: 8, width: 4, height: 2, name: 'a.png' }
|
|
const value = { attachment, data: 'synthetic' }
|
|
const rpc = core.rpc.bind(core)
|
|
vi.spyOn(core, 'rpc').mockImplementation(async (method, params) => {
|
|
if (method !== 'harness.remote.call') return rpc(method, params)
|
|
expect(params).toEqual({
|
|
endpoint: 'session/attachment',
|
|
payload: { args: { request: { sessionId: 's1', attachmentId: 'a1', attachment } } },
|
|
})
|
|
if (mode === 'disconnected') await connection.close()
|
|
if (mode === 'cancelled') controller.abort()
|
|
return { ok: true, value: mode === 'business-result' ? { ok: true, value }
|
|
: mode === 'denied' ? { ok: false, error: { code: 'not-found' } } : value }
|
|
})
|
|
try {
|
|
const result = connection.readSessionImageAttachment('s1', attachment, controller.signal)
|
|
if (mode === 'direct' || mode === 'business-result') await expect(result).resolves.toEqual(value)
|
|
else await expect(result).rejects.toThrow()
|
|
} finally { await connection.close() }
|
|
// Messages recorded before 0.2.2 kept only the durable id; keep that fallback for older Hosts.
|
|
prepareScenario1()
|
|
testState.capabilities = ['harness.remote.v1', 'harness.remote.transfer.v1']
|
|
const legacyConnection = new AndroidRemoteConnection()
|
|
await legacyConnection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)
|
|
const legacyCore = testState.cores[0]!
|
|
const legacyRpc = legacyCore.rpc.bind(legacyCore)
|
|
vi.spyOn(legacyCore, 'rpc').mockImplementation(async (method, params) => {
|
|
if (method !== 'harness.remote.call') return legacyRpc(method, params)
|
|
expect(params).toEqual({
|
|
endpoint: 'session/attachment',
|
|
payload: { args: { request: { sessionId: 's1', attachmentId: 'a1' } } },
|
|
})
|
|
return { ok: true, value }
|
|
})
|
|
try {
|
|
await expect(legacyConnection.readSessionImageAttachment('s1', { attachmentId: 'a1' }, new AbortController().signal))
|
|
.resolves.toEqual(value)
|
|
} finally { await legacyConnection.close() }
|
|
} })))
|
|
})
|
|
|
|
it('binds Bot requests to the advertised encrypted Host and rejects retired clients', async () => {
|
|
await runScenarios(['unsupported', 'current', 'replaced', 'revoked'].map(outcome => ({ name: outcome, run: async () => {
|
|
prepareScenario1()
|
|
if (outcome !== 'unsupported') testState.capabilities.push('plugin.route.v1')
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)
|
|
const core = testState.cores[0]!
|
|
if (outcome === 'unsupported') {
|
|
expect(() => connection.requireBotClient()).toThrow()
|
|
expect(core.rpcCalls.some(call => call.method === 'plugin.route.call')).toBe(false)
|
|
} else {
|
|
const client = connection.requireBotClient()
|
|
if (outcome === 'current') {
|
|
vi.spyOn(core, 'rpc').mockResolvedValueOnce({ status: 200, json: { ok: true, value: { bots: [], rooms: [] } } })
|
|
await expect(client.state()).resolves.toMatchObject({ bots: [], rooms: [] })
|
|
expect(core.rpc).toHaveBeenCalledWith('plugin.route.call', { route: 'api/bot', body: { endpoint: 'state', payload: null } }, undefined)
|
|
} else {
|
|
if (outcome === 'replaced') await connection.connect('https://server.example.com', identity, { ...host, deviceId: 'host-2' }, 'synthetic', () => undefined)
|
|
else { testState.capabilities = ['harness.remote.v1']; await connection.refreshBackends() }
|
|
const spy = vi.spyOn(core, 'rpc')
|
|
await expect(client.call('send', { sessionId: 'bot', text: 'hello' })).rejects.toThrow()
|
|
expect(spy).not.toHaveBeenCalled()
|
|
}
|
|
}
|
|
await connection.close()
|
|
} })))
|
|
})
|
|
|
|
it('periodically verifies the encrypted Host path and retires silent carriers without touching replacements', async () => {
|
|
await runScenarios(['healthy', 'silent', 'shared-probe', 'replaced', 'disconnected'].map(outcome => ({ name: outcome, run: async () => {
|
|
vi.useFakeTimers()
|
|
const connection = new AndroidRemoteConnection()
|
|
const closed = vi.fn()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { onClose: closed })
|
|
const core = testState.cores[0]!
|
|
const rpc = vi.spyOn(core, 'rpc')
|
|
let finish!: (value: unknown) => void
|
|
if (outcome === 'silent') rpc.mockImplementation(() => new Promise((_resolve, reject) => {
|
|
setTimeout(() => reject(new Error('RPC_TIMEOUT')), 5_000)
|
|
}))
|
|
if (outcome === 'shared-probe' || outcome === 'replaced') {
|
|
rpc.mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
|
|
}
|
|
if (outcome === 'disconnected') await connection.close()
|
|
await vi.advanceTimersByTimeAsync(25_000)
|
|
if (outcome === 'silent') {
|
|
// A single slow probe must not retire the carrier; one fast
|
|
// confirmation probe follows before the connection is closed.
|
|
expect(closed).not.toHaveBeenCalled()
|
|
await vi.advanceTimersByTimeAsync(5_000)
|
|
expect(closed).not.toHaveBeenCalled()
|
|
await vi.advanceTimersByTimeAsync(10_000)
|
|
expect(closed).toHaveBeenCalledOnce()
|
|
expect(() => connection.requireProxy()).toThrow()
|
|
} else if (outcome === 'shared-probe') {
|
|
const resumed = connection.checkHealth()
|
|
expect(rpc).toHaveBeenCalledTimes(1)
|
|
finish({})
|
|
expect(await resumed).toBe(true)
|
|
} else if (outcome === 'replaced') {
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)
|
|
finish({})
|
|
await vi.advanceTimersByTimeAsync(0)
|
|
expect(closed).not.toHaveBeenCalled()
|
|
expect(connection.requireProxy()).toBeDefined()
|
|
} else if (outcome === 'healthy') {
|
|
expect(rpc).toHaveBeenCalledTimes(1)
|
|
await vi.advanceTimersByTimeAsync(25_000)
|
|
expect(rpc).toHaveBeenCalledTimes(2)
|
|
expect(closed).not.toHaveBeenCalled()
|
|
} else expect(rpc.mock.calls.some(([method]) => method === 'harness.transport.describe')).toBe(false)
|
|
await connection.close()
|
|
const calls = rpc.mock.calls.length
|
|
await vi.advanceTimersByTimeAsync(60_000)
|
|
expect(rpc).toHaveBeenCalledTimes(calls)
|
|
vi.useRealTimers()
|
|
} })), async () => {
|
|
await Promise.all(testState.cores.map(core => core.close()))
|
|
vi.clearAllTimers()
|
|
prepareScenario1()
|
|
})
|
|
})
|
|
|
|
it('starts a replacement carrier with a clean health-probe history', async () => {
|
|
vi.useFakeTimers()
|
|
try {
|
|
const connection = new AndroidRemoteConnection()
|
|
const closed = vi.fn()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { onClose: closed })
|
|
// One failed probe on the first carrier: the confirmation probe is still
|
|
// pending when the carrier is replaced.
|
|
vi.spyOn(testState.cores[0]!, 'rpc').mockRejectedValue(new Error('probe failed'))
|
|
await vi.advanceTimersByTimeAsync(25_000)
|
|
expect(closed).not.toHaveBeenCalled()
|
|
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { onClose: closed })
|
|
vi.spyOn(testState.cores[1]!, 'rpc').mockRejectedValue(new Error('probe failed'))
|
|
await vi.advanceTimersByTimeAsync(25_000)
|
|
// The first probe on the replacement is not yet a confirmation: the
|
|
// previous carrier's failure must not count against the new one.
|
|
expect(closed).not.toHaveBeenCalled()
|
|
await vi.advanceTimersByTimeAsync(5_000)
|
|
expect(closed).toHaveBeenCalledOnce()
|
|
await connection.close()
|
|
} finally {
|
|
vi.useRealTimers()
|
|
}
|
|
})
|
|
|
|
it('preserves transient versus refused carrier failures through the close callback', async () => {
|
|
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
|
|
try {
|
|
await runScenarios([
|
|
{ reason: 'webrtc-closed' as const, retryable: true },
|
|
{ reason: 'control-error' as const, retryable: true },
|
|
{ reason: 'control-closed' as const, closeCode: 1006, retryable: true },
|
|
{ reason: 'control-closed' as const, closeCode: 4001, closeReason: 'CONNECTION_FAILED', retryable: true },
|
|
{ reason: 'control-closed' as const, closeCode: 4001, closeReason: 'RATE_LIMITED', retryable: false },
|
|
{ reason: 'control-closed' as const, closeCode: 4009, closeReason: 'heartbeat timeout', retryable: true },
|
|
{ reason: 'control-closed' as const, closeCode: 4009, closeReason: 'server shutdown', retryable: true },
|
|
{ reason: 'control-closed' as const, closeCode: 4003, retryable: false },
|
|
{ reason: 'control-closed' as const, closeCode: 1008, retryable: false },
|
|
{ reason: 'invalid-control-frame' as const, retryable: false },
|
|
].map(({ retryable, ...event }) => ({ name: `${event.reason}:${event.closeCode ?? ''}`, run: async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
const closed = vi.fn()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { onClose: closed })
|
|
testState.transportOptions[0]!.onDisconnect?.(event)
|
|
await testState.cores[0]!.close()
|
|
expect(closed).toHaveBeenCalledOnce()
|
|
expect(closed).toHaveBeenCalledWith({ retryable })
|
|
expect(() => connection.requireProxy()).toThrow()
|
|
await connection.close()
|
|
} })), prepareScenario1)
|
|
} finally { warn.mockRestore() }
|
|
})
|
|
|
|
it('checks an encrypted round trip after resume and rejects stale or failed health replies', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'healthy carrier uses the existing bounded capability RPC',
|
|
run: async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
expect(await connection.checkHealth()).toBe(false)
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { forceRelay: true })
|
|
const rpc = vi.spyOn(testState.cores[0]!, 'rpc')
|
|
expect(await connection.checkHealth()).toBe(true)
|
|
expect(rpc).toHaveBeenLastCalledWith('harness.transport.describe', {}, undefined, { timeoutMs: 5_000 })
|
|
await connection.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'a failed round trip cannot claim that a locally open socket is healthy',
|
|
run: async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { forceRelay: true })
|
|
vi.spyOn(testState.cores[0]!, 'rpc').mockRejectedValueOnce(new Error('RPC_TIMEOUT'))
|
|
expect(await connection.checkHealth()).toBe(false)
|
|
await connection.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'rejects health replies from a Host that no longer provides capability discovery',
|
|
run: async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { forceRelay: true })
|
|
vi.spyOn(testState.cores[0]!, 'rpc').mockRejectedValueOnce(Object.assign(new Error('unsupported'), { code: 'METHOD_NOT_FOUND' }))
|
|
expect(await connection.checkHealth()).toBe(false)
|
|
await connection.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'a late successful reply cannot validate a replacement carrier',
|
|
run: async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { forceRelay: true })
|
|
let finish!: (value: unknown) => void
|
|
vi.spyOn(testState.cores[0]!, 'rpc').mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
|
|
const checking = connection.checkHealth()
|
|
await connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined, { forceRelay: true })
|
|
finish({})
|
|
expect(await checking).toBe(false)
|
|
await connection.close()
|
|
},
|
|
},
|
|
], prepareScenario1)
|
|
})
|
|
|
|
it('does not let a late connection attempt overwrite or close its replacement', async () => {
|
|
const connection = new AndroidRemoteConnection()
|
|
let release!: () => void
|
|
testState.connectGate = () => new Promise<void>(resolve => { release = resolve })
|
|
const first = connection.connect('https://server.example.com', identity, host, 'access-token', () => undefined, { forceRelay: true })
|
|
.then(() => undefined, error => error)
|
|
await vi.waitFor(() => expect(testState.cores).toHaveLength(1))
|
|
testState.connectGate = undefined
|
|
await connection.connect('https://server.example.com', identity, host, 'access-token', () => undefined, { forceRelay: true })
|
|
const latest = connection.requireProxy()
|
|
release()
|
|
expect(await first).toBeInstanceOf(Error)
|
|
expect(connection.requireProxy()).toBe(latest)
|
|
await connection.close()
|
|
})
|
|
|
|
it('marks a failed native event stream offline instead of keeping a silent connected channel', async () => {
|
|
testState.capabilities = ['harness.remote.v1', 'harness.remote.transfer.v1']
|
|
const connection = new AndroidRemoteConnection()
|
|
const closed = vi.fn()
|
|
await connection.connect('https://server.example.com', identity, host, 'access-token', () => undefined, { forceRelay: true, onClose: closed })
|
|
const core = testState.cores[0]!
|
|
const opening = core.rpcCalls.find(call => call.method === 'harness.remote.stream.open'
|
|
&& (call.params as { endpoint?: string }).endpoint === '$events')!
|
|
core.emit({ event: 'harness.remote.stream.closed', data: {
|
|
streamId: (opening.params as { streamId: string }).streamId, reason: 'failed',
|
|
failure: { code: 'TRANSPORT_CLOSED', message: 'synthetic', details: {} },
|
|
} })
|
|
await vi.waitFor(() => expect(closed).toHaveBeenCalledTimes(1))
|
|
expect(() => connection.requireProxy()).toThrow()
|
|
await connection.close()
|
|
})
|
|
|
|
it('requires independent backend capability and readiness and refreshes Host switches live', async () => {
|
|
const rows = ['cursor', 'antigravity', 'pi'] as const
|
|
await runScenarios(
|
|
rows.map((row, index) => {
|
|
const backend = row
|
|
return {
|
|
name: scenarioName(
|
|
'requires %s capability and readiness and refreshes Host switches live',
|
|
row,
|
|
index,
|
|
),
|
|
run: async () => {
|
|
const capability = `agent.acp.${backend}.v1`
|
|
const type = { id: backend, name: backend, capability, available: false }
|
|
testState.capabilities = ['harness.remote.v1', capability]
|
|
testState.workspaceTypes = [type]
|
|
const connection = new AndroidRemoteConnection()
|
|
const available = () =>
|
|
backend === 'pi' ? connection.hasPi() : backend === 'cursor' ? connection.hasCursor() : connection.hasAntigravity()
|
|
await connection.connect(
|
|
'https://server.example.com',
|
|
identity,
|
|
host,
|
|
'access-token',
|
|
() => undefined,
|
|
{ forceRelay: true },
|
|
)
|
|
expect(available()).toBe(false)
|
|
testState.workspaceTypes = [{ ...type, available: true }]
|
|
await connection.refreshBackends()
|
|
expect(available()).toBe(true)
|
|
testState.capabilities = ['harness.remote.v1', 'agent.acp.v1']
|
|
await connection.refreshBackends()
|
|
expect(available()).toBe(false)
|
|
testState.capabilities = ['harness.remote.v1', capability]
|
|
await connection.refreshBackends()
|
|
expect(available()).toBe(true)
|
|
testState.workspaceTypes = [{ ...type, available: false }]
|
|
await connection.refreshBackends()
|
|
expect(available()).toBe(false)
|
|
await connection.close()
|
|
},
|
|
}
|
|
}),
|
|
async () => {
|
|
await prepareScenario1()
|
|
},
|
|
)
|
|
})
|
|
|
|
it('preserves CodeX capability discovery for Hosts without workspaceTypes', async () => {
|
|
testState.capabilities = ['harness.remote.v1', 'codex.appserver.v1', 'codex.appserver.transfer.v1']
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'access-token', () => undefined, { forceRelay: true })
|
|
expect(connection.hasCodex()).toBe(true)
|
|
testState.workspaceTypes = [{ id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: false }]
|
|
await connection.refreshBackends()
|
|
expect(connection.hasCodex()).toBe(false)
|
|
await connection.close()
|
|
})
|
|
|
|
it('rejects ApiProxy-only and undiscoverable Hosts without sending legacy traffic', async () => {
|
|
await runScenarios(['api-only', 'no-discovery'].map(mode => ({ name: mode, run: async () => {
|
|
prepareScenario1()
|
|
testState.capabilities = ['harness.api.v1', 'harness.api.transfer.v1']
|
|
const spy = mode === 'no-discovery' ? vi.spyOn(FakeCore.prototype, 'rpc').mockRejectedValueOnce(
|
|
Object.assign(new Error('unknown method'), { code: 'METHOD_NOT_FOUND' }),
|
|
) : undefined
|
|
const connection = new AndroidRemoteConnection()
|
|
try {
|
|
await expect(connection.connect('https://server.example.com', identity, host, 'synthetic', () => undefined)).rejects.toThrow()
|
|
expect(() => connection.requireProxy()).toThrow()
|
|
expect(testState.cores[0]?.rpcCalls.some(call => call.method.startsWith('harness.api.'))).toBe(false)
|
|
} finally { spy?.mockRestore(); await connection.close() }
|
|
} })))
|
|
})
|
|
|
|
it('uses v0.1.2 Typert Remote without opening the ApiProxy mux', async () => {
|
|
testState.capabilities = ['harness.remote.v1', 'harness.remote.transfer.v1']
|
|
const connection = new AndroidRemoteConnection()
|
|
await connection.connect('https://server.example.com', identity, host, 'access-token', () => undefined, { forceRelay: true })
|
|
const proxy = connection.requireProxy()
|
|
|
|
await proxy.sessionSelectPermission('session-1', 'default')
|
|
|
|
const methods = testState.cores[0]?.rpcCalls.map(call => call.method) ?? []
|
|
expect(methods).not.toContain('harness.api.stream.open')
|
|
expect(testState.cores[0]?.rpcCalls).toContainEqual({
|
|
method: 'harness.remote.call',
|
|
params: {
|
|
endpoint: 'commands/execute',
|
|
payload: { args: { agentId: 'session-1', line: '/permission default', images: [] } },
|
|
},
|
|
})
|
|
|
|
await connection.close()
|
|
})
|
|
})
|