Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

4.7 KB
Raw Blame
/** Opt-in two-machine fixture for Desktop's remote_media_smoke_test.dart.
 * A relays loopback app frames; B serves real files. Both use production E2EE
 * handshake/wrapping and media reads, with isolated identities and data dirs. */
import { WebSocket, WebSocketServer } from 'ws'
import { newIdentity, b64e, isWrapped } from '../src/lib/e2ee/core.js'
import { E2eeStore } from '../src/lib/e2ee/store.js'
import { E2eeManager } from '../src/lib/e2ee/manager.js'
import { RelaySessionCrypto } from '../src/lib/e2ee/relayClient.js'
import { MediaPreviewError, readMediaPreviewChunk } from '../src/lib/mediaPreview.js'

if (process.env.HARNESS_MEDIA_SMOKE !== '1' || !process.env.ADAPTER_DATA_DIR || !process.argv[2]) {
  throw new Error('This test fixture requires explicit smoke mode, an isolated data directory and an artifact directory.')
}
const root = process.argv[2]
const identityA = newIdentity()
const storeB = new E2eeStore()
const identityB = storeB.init()
storeB.addPaired(b64e(identityA.pub), 'Smoke machine A', Date.now())
const connections = new Map<string, WebSocket>()
let encryptedRequests = 0
let encryptedReplies = 0
let maxFrameBytes = 0
const managerB = new E2eeManager({
  machineId: 'smoke-B', isConnected: () => true,
  sendTo: (id, frame) => connections.get(id)?.send(JSON.stringify(frame)),
})
const peerB = new WebSocketServer({ host: '127.0.0.1', port: 0 })
await new Promise<void>(resolve => peerB.once('listening', resolve))
let sequence = 0
peerB.on('connection', socket => {
  const id = `smoke-A-${++sequence}`
  connections.set(id, socket)
  socket.on('close', () => { connections.delete(id); managerB.dropSession(id) })
  socket.on('message', async raw => {
    const frame = JSON.parse(raw.toString())
    if (frame.type.startsWith('e2e_')) { managerB.handleFrame(id, frame); return }
    if (frame.type !== 'agent_read_file' || !isWrapped(frame.payload)) throw new Error('Media request was not encrypted')
    encryptedRequests++
    const decoded = managerB.unwrapDown(id, frame)
    if (!decoded) throw new Error('Media request failed authentication')
    const payload = decoded.payload as Record<string, unknown>
    // Network fault injection is confined to this opt-in fixture.
    if (Number(payload.offset) > 0 && payload.smokeDisconnect) { socket.close(); return }
    if (Number(payload.offset) > 0 && payload.smokeDelay) await new Promise(resolve => setTimeout(resolve, 100))
    let result: Record<string, unknown>
    try {
      result = { ...await readMediaPreviewChunk(root, String(payload.path), payload.offset, payload.revision) }
    } catch (error) {
      result = { error: error instanceof MediaPreviewError ? error.message : 'MEDIA_READ_FAILED' }
    }
    if (socket.readyState !== WebSocket.OPEN) return
    const wrapped = managerB.wrapRpcReply(id, 'agent_read_file_result', payload.requestId, result)
    if (!wrapped || !isWrapped(wrapped.payload)) throw new Error('Media reply was not encrypted')
    const wire = JSON.stringify(wrapped)
    maxFrameBytes = Math.max(maxFrameBytes, Buffer.byteLength(wire))
    encryptedReplies++
    socket.send(wire)
  })
})

const appA = new WebSocketServer({ host: '127.0.0.1', port: 0 })
await new Promise<void>(resolve => appA.once('listening', resolve))
appA.on('connection', local => {
  const cryptoA = new RelaySessionCrypto({ machineId: 'smoke-B', selfIdentity: identityA, peerPub: identityB.pub })
  const peer = new WebSocket(`ws://127.0.0.1:${(peerB.address() as { port: number }).port}`)
  peer.on('open', () => peer.send(JSON.stringify(cryptoA.helloFrame())))
  peer.on('message', raw => {
    const frame = JSON.parse(raw.toString())
    if (frame.type === 'e2e_welcome') {
      if (!cryptoA.handleWelcome(frame.payload)) throw new Error('Smoke handshake failed')
      local.send(JSON.stringify({ type: 'connected', payload: { machineId: 'smoke-B' } }))
      return
    }
    const decoded = cryptoA.unwrapIncoming(frame)
    if (!decoded) throw new Error('Media reply failed authentication')
    if (local.readyState === WebSocket.OPEN) local.send(JSON.stringify(decoded))
  })
  peer.on('close', () => local.close())
  local.on('close', () => peer.close())
  local.on('message', raw => {
    const frame = JSON.parse(raw.toString())
    if (frame.type === 'machine_select') return
    if (frame.type === 'smoke_stats') {
      local.send(JSON.stringify({ type: 'smoke_stats_result', payload: {
        requestId: frame.payload.requestId, encryptedRequests, encryptedReplies, maxFrameBytes,
      } }))
      return
    }
    if (!cryptoA.ready) throw new Error('App sent media before the handshake')
    peer.send(JSON.stringify(cryptoA.wrapOutgoing(frame)))
  })
})
console.log(JSON.stringify({ port: (appA.address() as { port: number }).port }))
process.stdin.resume()
process.stdin.on('end', () => process.exit(0))