ds-harness-remote-fast/packages/plugin/tests/lan-upload.test.ts

181 lines
11 KiB
TypeScript

import { Server } from 'node:http'
import { randomUUID } from 'node:crypto'
import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { WebSocket } from 'ws'
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
import { generateKeyPair, NoiseIkSession } from '@dsh-remote/crypto'
import { SecureMessageCodec, createLanUploadPrologue, createRpcRequest, decodeMessage, encodeMessage, type LanUploadOffer } from '@dsh-remote/protocol'
import { LanUploadHost } from '../src/lan-upload.js'
import { WorkspaceUploadHost } from '../src/workspace-upload.js'
import { ConnectionController } from '../src/connection-controller.js'
import { RpcRouter } from '../src/rpc-router.js'
import type { IdentityStore } from '../src/identity-store.js'
import type { AuthenticatedPeerChannel } from '../src/types.js'
const address='192.168.41.8'
const hosts:LanUploadHost[]=[],uploads:WorkspaceUploadHost[]=[],roots:string[]=[],sockets:WebSocket[]=[]
// Bind real TCP sockets on loopback so the suite requires no physical LAN interface.
beforeEach(()=>{
const listen=Server.prototype.listen
vi.spyOn(Server.prototype,'listen').mockImplementation(function(this:Server,...args:any[]){
if(args[1]===address) args[1]='127.0.0.1'
return listen.apply(this,args as any)
} as typeof listen)
})
afterEach(async()=>{
for(const socket of sockets.splice(0)) socket.terminate()
await Promise.all(hosts.splice(0).map(h=>h.closeAll()))
await Promise.all(uploads.splice(0).map(h=>h.closeAll()))
await Promise.all(roots.splice(0).map(root=>rm(root,{recursive:true,force:true})))
vi.restoreAllMocks();vi.useRealTimers()
})
async function setup(){
const root=await mkdtemp(join(tmpdir(),'dsh-lan-upload-test-'));roots.push(root)
const client=generateKeyPair(),server=generateKeyPair()
let mode:string='LAN'
const upload=new WorkspaceUploadHost(async id=>id==='session-1'?root:undefined,undefined,()=>mode);uploads.push(upload)
const host=new LanUploadHost(upload,{connectionId:'connection-1',peerIdentityKey:client.publicKey,identity:()=>({...server,deviceId:'host',name:'host',fingerprint:'fp',schemaVersion:1}),mode:()=>mode},()=>[address]);hosts.push(host)
return {root,host,upload,client,server,setMode:(value:string)=>{mode=value},scope:{sessionId:'session-1',uploadId:randomUUID()},offer:(scope:{sessionId:string;uploadId:string})=>host.open({...scope,address})}
}
async function connect(offer:LanUploadOffer,client:ReturnType<typeof generateKeyPair>,server:ReturnType<typeof generateKeyPair>){
const socket=new WebSocket(offer.url.replace(address,'127.0.0.1'));sockets.push(socket)
const noise=new NoiseIkSession({role:'initiator',localPrivateKey:client.privateKey,localPublicKey:client.publicKey,remotePublicKey:server.publicKey,prologue:createLanUploadPrologue(offer)})
const incoming=new SecureMessageCodec(),outgoing=new SecureMessageCodec()
const pending=new Map<string,{resolve:(v:any)=>void;reject:(e:Error)=>void;timer:ReturnType<typeof setTimeout>}>()
let ready!:()=>void,fail!:(e:Error)=>void
const opened=new Promise<void>((resolve,reject)=>{ready=resolve;fail=reject})
const timer=setTimeout(()=>{socket.terminate();fail(new Error('Handshake timeout'))},1500)
const closed=()=>{
clearTimeout(timer);fail(new Error('Socket closed'))
for(const p of pending.values()){clearTimeout(p.timer);p.reject(new Error('Socket closed'))};pending.clear();noise.destroy()
}
socket.on('open',()=>socket.send(noise.writeHandshake()))
socket.on('close',closed);socket.on('error',closed)
socket.on('message',raw=>{
try {
const bytes=Buffer.from(raw as Buffer)
if(!noise.complete){noise.readHandshake(bytes);clearTimeout(timer);ready();return}
const frame=incoming.decode(noise.decrypt(bytes));if(!frame)return
const message=decodeMessage(frame),payload=message.payload as any,p=pending.get(payload.requestId)
if(!p)return
clearTimeout(p.timer);pending.delete(payload.requestId)
if(message.type==='rpc.error')p.reject(Object.assign(new Error(payload.message),{code:payload.code}));else p.resolve(payload.result)
}catch(error){fail(error as Error);socket.terminate()}
})
await opened
return {socket,rpc:(method:string,params:unknown)=>{
const message=createRpcRequest(method as any,params)
const response=new Promise<any>((resolve,reject)=>{const timer=setTimeout(()=>{pending.delete(message.id);reject(new Error('RPC timeout'))},1500);pending.set(message.id,{resolve,reject,timer})})
if(socket.readyState!==WebSocket.OPEN){const p=pending.get(message.id)!;clearTimeout(p.timer);pending.delete(message.id);p.reject(new Error('Socket closed'));return response}
for(const frame of outgoing.encode(encodeMessage(message))) socket.send(noise.encrypt(frame))
return response
}}
}
it('receives binary upload using a real pinned Noise/TCP connection and retains publication',async()=>{
const s=await setup(),offer=await s.offer(s.scope),client=await connect(offer,s.client,s.server)
const bytes=Buffer.alloc(256*1024,123)
expect(await client.rpc('workspace.upload.open',{...s.scope,name:'file.bin',totalBytes:bytes.length,encoding:'binary-v1'})).toMatchObject({uploadId:s.scope.uploadId,encoding:'binary-v1'})
expect(await client.rpc('workspace.upload.chunk.binary',{...s.scope,offset:0,data:bytes})).toMatchObject({receivedBytes:bytes.length})
expect(await client.rpc('workspace.upload.commit',s.scope)).toEqual({name:'file.bin',path:'./file.bin',bytes:bytes.length})
await s.host.closeAll()
expect(await readFile(join(s.root,'file.bin'))).toEqual(bytes)
})
it('rejects non-LAN modes, foreign interfaces and public addresses before creating listeners',async()=>{
const s=await setup()
for(const mode of ['P2P','TURN','Relay','Disconnected']){s.setMode(mode);await expect(s.offer(s.scope)).rejects.toMatchObject({code:'FEATURE_NOT_SUPPORTED'})}
s.setMode('LAN')
for(const ip of ['127.0.0.1','8.8.8.8','192.168.41.9'])await expect(s.host.open({...s.scope,address:ip})).rejects.toMatchObject({code:'FEATURE_NOT_SUPPORTED'})
})
it('consumes tickets once and rejects another device static key',async()=>{
const s=await setup(),offer=await s.offer(s.scope)
const first=await connect(offer,s.client,s.server)
await expect(connect(offer,s.client,s.server)).rejects.toThrow()
first.socket.terminate()
const second=await s.offer({...s.scope,uploadId:randomUUID()})
await expect(connect(second,generateKeyPair(),s.server)).rejects.toThrow()
expect(await readdir(s.root)).toEqual([])
})
it('never opens or commits files for a different upload/session or unrelated RPC',async()=>{
const s=await setup()
for(const request of [
{method:'workspace.upload.open',params:{...s.scope,uploadId:randomUUID(),name:'bad.bin',totalBytes:1,encoding:'binary-v1'}},
{method:'workspace.upload.open',params:{...s.scope,sessionId:'other',name:'bad.bin',totalBytes:1,encoding:'binary-v1'}},
{method:'harness.remote.call',params:s.scope},
]){
const scope={...s.scope,uploadId:randomUUID()},offer=await s.offer(scope),client=await connect(offer,s.client,s.server)
await expect(client.rpc(request.method,{...request.params,uploadId:request.params.uploadId===s.scope.uploadId?scope.uploadId:request.params.uploadId})).rejects.toThrow()
}
expect(await readdir(s.root)).toEqual([])
})
it('cleans partial data on control-owner close, socket loss and LAN fallback',async()=>{
for(const cause of ['owner','socket','mode']){
const s=await setup(),offer=await s.offer(s.scope),client=await connect(offer,s.client,s.server)
await client.rpc('workspace.upload.open',{...s.scope,name:'partial.bin',totalBytes:2,encoding:'binary-v1'})
await client.rpc('workspace.upload.chunk.binary',{...s.scope,offset:0,data:Buffer.from('a')})
if(cause==='owner')await s.host.closeAll()
if(cause==='socket')client.socket.terminate()
if(cause==='mode'){s.setMode('Relay');await expect(client.rpc('workspace.upload.commit',s.scope)).rejects.toThrow()}
await vi.waitFor(async()=>expect(await readdir(s.root)).toEqual([]))
}
})
it('limits outstanding tickets and closes listeners even when shutdown races binding',async()=>{
const s=await setup()
await s.offer(s.scope);await s.offer({...s.scope,uploadId:randomUUID()})
await expect(s.offer({...s.scope,uploadId:randomUUID()})).rejects.toMatchObject({code:'FEATURE_NOT_SUPPORTED'})
await s.host.closeAll()
const other=await setup(),opening=other.offer(other.scope)
const rejected=expect(opening).rejects.toMatchObject({code:'FEATURE_NOT_SUPPORTED'})
await other.host.closeAll();await rejected
})
it('expires unused tickets without accepting a later connection',async()=>{
const s=await setup()
vi.useFakeTimers()
const offer=await s.offer(s.scope)
await vi.advanceTimersByTimeAsync(10001)
vi.useRealTimers()
await expect(connect(offer,s.client,s.server)).rejects.toThrow()
expect(await readdir(s.root)).toEqual([])
})
it('rechecks workspace authority at commit and discards files after session revocation',async()=>{
const s=await setup()
const { root }=s
let authorized=true
const upload=new WorkspaceUploadHost(async()=>authorized?root:undefined,undefined,()=> 'LAN');uploads.push(upload)
const host=new LanUploadHost(upload,{connectionId:'connection-1',peerIdentityKey:s.client.publicKey,identity:()=>({...s.server,deviceId:'host',name:'host',fingerprint:'fp',schemaVersion:1}),mode:()=> 'LAN'},()=>[address]);hosts.push(host)
const offer=await host.open({...s.scope,address}),client=await connect(offer,s.client,s.server)
await client.rpc('workspace.upload.open',{...s.scope,name:'revoked.bin',totalBytes:1,encoding:'binary-v1'})
await client.rpc('workspace.upload.chunk.binary',{...s.scope,offset:0,data:Buffer.from('a')})
authorized=false
await expect(client.rpc('workspace.upload.commit',s.scope)).rejects.toThrow()
await vi.waitFor(async()=>expect(await readdir(root)).toEqual([]))
})
it('retires real TCP listeners and partial files through controller replacement, disconnect and device revocation',async()=>{
for(const cause of ['replacement','disconnect','revocation']){
const s=await setup()
const controller=new ConnectionController({isTrusted:()=>true} as unknown as IdentityStore,
()=>new RpcRouter(128,undefined,undefined,undefined,undefined,undefined,undefined,undefined,undefined,undefined,s.upload,undefined,s.host))
const channel=(connectionId:string):AuthenticatedPeerChannel=>({
security:{protocol:'Noise_IK_25519_ChaChaPoly_SHA256',connectionId,membershipId:'fixture-membership'},
peerDeviceId:'fixture-phone',peerIdentityKey:s.client.publicKey,mode:'LAN',
send:async()=>{},close:async()=>{},onMessage:()=>()=>{},
})
try {
await controller.accept(channel('connection-1'))
const offer=await s.offer(s.scope),client=await connect(offer,s.client,s.server)
await client.rpc('workspace.upload.open',{...s.scope,name:'partial.bin',totalBytes:2,encoding:'binary-v1'})
await client.rpc('workspace.upload.chunk.binary',{...s.scope,offset:0,data:Buffer.from('a')})
expect((await readdir(s.root)).some(name=>name.endsWith('.part'))).toBe(true)
if(cause==='replacement')await controller.accept(channel('connection-2'))
if(cause==='disconnect')await controller.closeConnection('connection-1')
if(cause==='revocation')await controller.revoke('fixture-phone')
expect(await readdir(s.root)).toEqual([])
await vi.waitFor(()=>expect(client.socket.readyState).toBe(WebSocket.CLOSED))
await expect(connect(offer,s.client,s.server)).rejects.toThrow()
await expect(client.rpc('workspace.upload.commit',s.scope)).rejects.toThrow()
} finally { await controller.close() }
}
})