yaoyao/tests/server/desktopEnvironments.test.ts

// @vitest-environment node
import {afterEach,beforeEach,expect,it,vi} from 'vitest'
import {mkdtempSync,rmSync} from 'node:fs'
import {tmpdir} from 'node:os'
import {join} from 'node:path'
import {randomUUID,createHash} from 'node:crypto'
import Koa from 'koa'
import {bodyParser} from '@koa/bodyparser'
import request from 'supertest'
import {WorkspaceStore} from '../../src/server/workspaceStore'
import {DesktopEnvironments} from '../../src/server/desktopEnvironments'
import type {WorkspaceAgent} from '../../src/shared/workspace'
import {HttpError} from '../../src/server/errors'
import {acquireServiceInstance} from '../../src/server/serviceInstance'
let home:string,store:WorkspaceStore,service:DesktopEnvironments,agent:WorkspaceAgent,version:number,host:any,poller:ReturnType<typeof setInterval>|undefined
const auth={require:(ctx:any)=>({id:ctx.get('x-user')||'owner'}),requireAdmin:(ctx:any)=>{if(ctx.get('x-user'))throw new HttpError(403,'仅限管理员','admin_required')},pushAuthorizationVersion:()=>version} as any
const nodes={localNodeID:'local-node',requireSource:()=>{}} as any
const ownerKey=(owner:string)=>createHash('sha256').update('local-node:'+owner).digest('hex')
beforeEach(()=>{home=mkdtempSync(join(tmpdir(),'desktop-env-'));store=new WorkspaceStore(home);service=new DesktopEnvironments(store,auth,nodes);version=1;agent=store.createAgent('owner',{name:'Browser',nodeId:'local',profile:'default',computer:'browser'});host={id:randomUUID(),name:'测试 Mac',platform:'darwin',screen:true,accessibility:true,approved:[ownerKey('owner')]}})
const pollers=new Set<ReturnType<typeof setInterval>>()
afterEach(()=>{clearInterval(poller);for(const p of pollers)clearInterval(p);pollers.clear();service.close();store.close();rmSync(home,{recursive:true,force:true});vi.useRealTimers()})
const app=()=>{const a=new Koa();a.use(async(ctx,next)=>{try{await next()}catch(e:any){ctx.status=e.status??500;ctx.body={error:e.message,code:e.code}}});a.use(bodyParser());a.use(service.router().routes());return a.callback()}
const base=()=>'/api/app/agents/'+agent.id
it('adds an authorized native desktop to hybrid tools while leaving the default viewer on the VM',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'vm',execution:'computer',allowHostEnvironment:true})
 expect(agent.execution).toBe('computer');expect(service.toolMode('owner',agent)).toBeUndefined()
 drive();expect(service.selected('owner',agent)).toBeUndefined();expect(service.toolMode('owner',agent)).toBe('local')
 const result=await service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'local',service.epoch)
 expect(result.content[0].type).toBe('image')
 agent=store.updateAgent('owner',agent.id,{computer:'vm',allowHostEnvironment:false});expect(service.toolMode('owner',agent)).toBeUndefined()
 await expect(service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'local',service.epoch)).rejects.toMatchObject({code:'computer_control_expired'})
})
function drive(handle:(c:any)=>unknown=c=>c.operation==='view'?{data:Buffer.from('fixture frame').toString('base64'),width:1280,height:800}:{ok:true}){let results:any[]=[];service.exchange({host,results});const p=setInterval(()=>{const value=service.exchange({host,results});results=value.commands.map(c=>({id:c.id,value:handle(c)}))},5);pollers.add(p);poller=p}
const HOST_A='11111111-aaaa-4bbb-8ccc-111111111111',HOST_B='22222222-aaaa-4bbb-8ccc-222222222222'
function driveRemote(id:string,hostInfo:any,handle:(c:any)=>unknown=c=>c.operation==='view'?{data:Buffer.from('remote frame').toString('base64'),width:1280,height:800}:{ok:true}){let results:any[]=[];service.remoteExchange(id,{host:hostInfo,results});const p=setInterval(()=>{const value=service.remoteExchange(id,{host:hostInfo,results});results=value.commands.map(c=>({id:c.id,value:handle(c)}))},5);pollers.add(p);poller=p}
it('defaults bot work to the customer machine and uses that binding while the server desktop is also online',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local',desktopHost:HOST_A})
 const remoteHost={...host,name:'客厅 Mac Pro'}
 driveRemote(HOST_A,remoteHost)
 drive()
 const state=(await request(app()).get(base()+'/desktop-environment')).body
 expect(state.hostName??state.host?.name).toBe('客厅 Mac Pro')
 const named=(await request(app()).get(base()+'/computer?backend=desktop&host='+encodeURIComponent('客厅 Mac Pro'))).body
 expect(named.hostName).toBe('客厅 Mac Pro')
 vi.useFakeTimers()
 clearInterval(poller)
 vi.advanceTimersByTime(9000)
 const fallback=(await request(app()).get(base()+'/desktop-environment')).body
 expect(fallback.hostName??fallback.host?.name).toBe('客厅 Mac Pro')
 const epoch=service.hostEpoch('owner',agent)
 expect(epoch).toBe(remoteHost.id)
 const result=await service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'local',epoch)
 expect(result.content[0].type).toBe('image')
 expect(JSON.parse(result.content[1].text).host).toBe('客厅 Mac Pro')
 vi.useRealTimers()
 const hosts=(await request(app()).get(base()+'/desktop-environment')).body
 expect(hosts.hosts.map((h:any)=>h.id)).toEqual(['local',HOST_A])
 expect(hosts.hosts.find((h:any)=>h.id===HOST_A)).toMatchObject({name:'客厅 Mac Pro',online:true})
})
it('requires an explicit binding when several remote hosts are connected',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local'})
 service.remoteExchange(HOST_A,{host:{...host,name:'书房'},results:[]})
 service.remoteExchange(HOST_B,{host:{...host,name:'客厅'},results:[]})
 const state=(await request(app()).get(base()+'/desktop-environment')).body
 expect(state.online).toBe(false)
 expect(state.hosts).toHaveLength(2)
 await request(app()).get(base()+'/computer/frame').expect(409)
 agent=store.updateAgent('owner',agent.id,{desktopHost:HOST_B})
 driveRemote(HOST_B,{...host,name:'客厅'})
 const status=(await request(app()).get(base()+'/computer')).body
 expect(status.hostName).toBe('客厅')
 const ticket=await take()
 await request(app()).post(base()+'/computer/giveback').send(ticket).expect(200)
})
it('lets the manual viewer take over any connected host via the host parameter',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local',desktopHost:HOST_B})
 driveRemote(HOST_A,{...host,name:'书房'},c=>c.operation==='view'?{data:Buffer.from('study frame').toString('base64'),width:1280,height:800}:{ok:true})
 driveRemote(HOST_B,{...host,name:'客厅'},c=>c.operation==='view'?{data:Buffer.from('living frame').toString('base64'),width:1280,height:800}:{ok:true})
 const study='?backend=desktop&host='+encodeURIComponent(HOST_A)
 const status=(await request(app()).get(base()+'/computer'+study)).body
 expect(status.hostName).toBe('书房');expect(status.mode).toBe('idle')
 const ticket=(await request(app()).post(base()+'/computer/take'+study).send({requestId:randomUUID()}).expect(200)).body
 expect(ticket.hostName).toBe('书房')
 const bound=(await request(app()).get(base()+'/computer?backend=desktop')).body
 expect(bound.hostName).toBe('客厅');expect(bound.mode).toBe('idle')
 const frame=await request(app()).get(base()+'/computer/frame'+study).expect(200)
 expect(Buffer.from(frame.body.data,'base64').toString()).toBe('study frame')
 await request(app()).post(base()+'/computer/giveback'+study).send({controlId:ticket.controlId,token:ticket.token}).expect(200)
 const response=await request(app()).get(base()+'/computer?backend=desktop&host=nope').expect(409)
 expect(response.body.code).toBe('desktop_host_unknown')
})
it('revoking a desktop host fences only its dispatched commands',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local',desktopHost:HOST_A})
 service.remoteExchange(HOST_A,{host,results:[]})
 const call=service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'local',service.hostEpoch('owner',agent))
 await vi.waitFor(()=>{expect(service.remoteExchange(HOST_A,{host,results:[]}).commands).toHaveLength(1)})
 service.dropHost(HOST_A)
 await expect(call).rejects.toMatchObject({code:'desktop_disconnected'})
})
it('gates file and shell tools behind the separate full grant',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local'})
 service.exchange({host,results:[]})
 expect(service.fileTools('owner',agent)).toBe(false)
 await expect(service.call('owner',agent.id,'desktop_file_read',{path:'notes.txt'},new AbortController().signal,()=>{},'local',service.hostEpoch('owner',agent))).rejects.toMatchObject({code:'desktop_full_required'})
 await expect(service.call('owner',agent.id,'desktop_shell',{command:'ls'},new AbortController().signal,()=>{},'local',service.hostEpoch('owner',agent))).rejects.toMatchObject({code:'desktop_full_required'})
 const seen:any[]=[]
 drive(c=>{seen.push(c);return c.operation==='view'?{data:'Zm9v',width:1280,height:800}:{op:'list',entries:[]}})
 host.full=[ownerKey('owner')]
 service.exchange({host,results:[]})
 expect(service.fileTools('owner',agent)).toBe(true)
 const listing=await service.call('owner',agent.id,'desktop_file_list',{path:'Documents'},new AbortController().signal,()=>{},'local',service.hostEpoch('owner',agent))
 expect(listing.entries).toEqual([])
 expect(seen.find(c=>c.operation==='file')?.action).toMatchObject({op:'list',path:'Documents'})
 await expect(service.call('owner',agent.id,'desktop_file_write',{path:'a.txt',data:'!!!not base64!!!'},new AbortController().signal,()=>{},'local',service.hostEpoch('owner',agent))).rejects.toMatchObject({status:400})
})
it('passes the authorize scope through to the desktop host',async()=>{
 const seen:any[]=[]
 drive(c=>{seen.push(c);return {ok:true}})
 await request(app()).post(base()+'/desktop-environment/authorize').send({scope:'full'}).expect(200)
 expect(seen.find(c=>c.operation==='authorize')?.scope).toBe('full')
})
it('routes parallel desktop tools to the host named in the call',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local',envs:{desktop:true,cloud:true}})
 const study={...host,name:'书房 iMac'},living={...host,id:randomUUID(),name:'客厅 Mac mini'}
 driveRemote(HOST_A,study)
 let resultsB:any[]=[]
 service.remoteExchange(HOST_B,{host:living,results:[]})
 const pollerB=setInterval(()=>{const value=service.remoteExchange(HOST_B,{host:living,results:resultsB});resultsB=value.commands.map(c=>({id:c.id,value:c.operation==='view'?{data:Buffer.from('living-room').toString('base64'),width:1280,height:800}:{ok:true}}))},5)
 try{
  expect(service.envTools('owner',agent)).toEqual({view:true,browser:false,file:false})
  const frame=await service.call('owner',agent.id,'desktop_environment_view',{host:'客厅 Mac mini'},new AbortController().signal,()=>{},'local',service.hostEpochs('owner',agent))
  expect(Buffer.from(frame.content[0].data,'base64').toString()).toBe('living-room')
  await expect(service.call('owner',agent.id,'desktop_environment_view',{host:'书房 iMac'},new AbortController().signal,()=>{},'local',service.hostEpochs('owner',agent))).resolves.toMatchObject({content:[{type:'image'},{type:'text'}]})
  await expect(service.call('owner',agent.id,'desktop_environment_view',{host:'地下室 MacBook'},new AbortController().signal,()=>{},'local',service.hostEpochs('owner',agent))).rejects.toMatchObject({code:'desktop_host_unknown'})
  expect(service.onlineHostsLine('owner')).toContain('书房 iMac')
 }finally{clearInterval(pollerB)}
})
it('keeps desktop and browser tools open together when both environments are on',async()=>{
 agent=store.updateAgent('owner',agent.id,{envs:{vm:true,desktop:true,browser:true,cloud:false}})
 drive()
 expect(service.selected('owner',agent)).toBe('local')
 expect(service.toolMode('owner',agent)).toBe('local')
 await expect(service.call('owner',agent.id,'desktop_browser',{kind:'navigate',url:'https://example.test/both'},new AbortController().signal,()=>{},'browser',service.epoch)).resolves.toEqual({ok:true})
 const view=await service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'local',service.epoch)
 expect(view.content[0].type).toBe('image')
})
it('degrades envs desktop tools when no host is ready or online',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'off',envs:{desktop:true,browser:true}})
 expect(service.envTools('owner',agent)).toEqual({view:false,browser:false,file:false})
 service.exchange({host,results:[]})
 expect(service.envTools('owner',agent)).toEqual({view:true,browser:true,file:false})
 host.full=[ownerKey('owner')]
 service.exchange({host,results:[]})
 expect(service.envTools('owner',agent)).toEqual({view:true,browser:true,file:true})
})
it('keeps manual takeover scoped per desktop host',async()=>{
 agent=store.updateAgent('owner',agent.id,{computer:'local',desktopHost:HOST_A})
 const second=store.createAgent('owner',{name:'Second',nodeId:'local',profile:'default',computer:'local',desktopHost:HOST_B})
 driveRemote(HOST_A,{...host,name:'书房'})
 let resultsB:any[]=[]
 const pollerB=setInterval(()=>{const value=service.remoteExchange(HOST_B,{host:{...host,name:'客厅'},results:resultsB});resultsB=value.commands.map(c=>({id:c.id,value:{ok:true}}))},5)
 try{
  const ticketA=await take()
  const ticketB=(await request(app()).post('/api/app/agents/'+second.id+'/computer/take').send({requestId:randomUUID()}).expect(200)).body
  expect(ticketB.hostName).toBe('客厅')
  const records=store.list<any>('_system','computer-control')
  expect(records).toHaveLength(2)
  expect(new Set(records.map(r=>r.environmentId.split(':')[1])).size).toBe(2)
  await request(app()).post(base()+'/computer/renew').send(ticketA).expect(200)
  await request(app()).post(base()+'/computer/giveback').send(ticketA).expect(200)
  await request(app()).post('/api/app/agents/'+second.id+'/computer/giveback').send(ticketB).expect(200)
 }finally{clearInterval(pollerB)}
})
async function take(){return (await request(app()).post(base()+'/computer/take').send({requestId:randomUUID()}).expect(200)).body}
async function frame(){return (await request(app()).get(base()+'/computer/frame').expect(200)).body}
it('queues browser operations from concurrent sessions and cancels only the waiting session',async()=>{
 service.exchange({host,results:[]})
 const first=new AbortController(),cancelled=new AbortController(),third=new AbortController()
 const navigate=(signal:AbortSignal,path:string)=>service.call('owner',agent.id,'desktop_browser',{kind:'navigate',url:`https://example.test/${path}`},signal,()=>{},'browser',service.epoch)
 const one=navigate(first.signal,'first'),two=navigate(cancelled.signal,'cancelled').catch(error=>error),three=navigate(third.signal,'third')
 let commands:any[]=[]
 await vi.waitFor(()=>{commands=service.exchange({host,results:[]}).commands;expect(commands).toHaveLength(1)})
 const initial=commands[0]
 expect(initial.action.url).toBe('https://example.test/first')
 expect(service.exchange({host,results:[]}).commands).toEqual([])
 cancelled.abort()
 service.exchange({host,results:[{id:initial.id,value:{ok:true}}]})
 await one
 expect(await two).toMatchObject({name:'AbortError'})
 await vi.waitFor(()=>{commands=service.exchange({host,results:[]}).commands;expect(commands).toHaveLength(1)})
 expect(commands[0].action.url).toBe('https://example.test/third')
 expect(commands[0].resource).toBe(initial.resource)
 service.exchange({host,results:[{id:commands[0].id,value:{ok:true}}]})
 await expect(three).resolves.toEqual({ok:true})
 expect(first.signal.aborted).toBe(false)
 expect(third.signal.aborted).toBe(false)
})
it('keeps capability private and refuses origins before parsing native commands',async()=>{const instance=acquireServiceInstance(home,'0.4.3'),a=new Koa().use(instance.middleware(async()=>{},()=>true,ctx=>service.bridge(ctx)));try{await request(a.callback()).post('/desktop/environment').send({host,results:[]}).expect(403);await request(a.callback()).post('/desktop/environment').set('x-yaoyao-desktop-token',instance.record.token).set('Origin','http://evil.test').send({host,results:[]}).expect(403);await request(a.callback()).post('/desktop/environment').set('x-yaoyao-desktop-token',instance.record.token).send({host,results:[]}).expect(200);expect(service.online).toBe(true)}finally{instance.release()}})
it('auto selects only an approved and ready local host; observing never opens a browser',async()=>{agent=store.updateAgent('owner',agent.id,{computer:'auto'});expect(service.selected('owner',agent)).toBeUndefined();expect(service.exchange({host:{...host,approved:[]},results:[]}).commands).toEqual([]);expect(service.selected('owner',agent)).toBeUndefined();service.exchange({host,results:[]});expect(service.selected('owner',agent)).toBe('local');host.screen=false;service.exchange({host,results:[]});expect(service.selected('owner',agent)).toBeUndefined();await request(app()).get(base()+'/desktop-environment').set('x-user','other').expect(404)})
it('shares the physical desktop across owners and robots but scopes manual tokens to their owner and robot',async()=>{agent=store.updateAgent('owner',agent.id,{computer:'local'});const other=store.createAgent('other',{name:'Other',nodeId:'local',profile:'default',computer:'local'});host.approved.push(ownerKey('other'));drive();const ticket=await take();await request(app()).post('/api/app/agents/'+other.id+'/computer/take').set('x-user','other').send({requestId:randomUUID()}).expect(409);await request(app()).post('/api/app/agents/'+other.id+'/computer/renew').set('x-user','other').send(ticket).expect(410);const state=(await request(app()).get('/api/app/agents/'+other.id+'/computer').set('x-user','other')).body;expect(state.controlId).toBeUndefined();await request(app()).post(base()+'/computer/giveback').send(ticket).expect(200)})
it('rejects stale frames and replays an input result exactly once',async()=>{const calls:any[]=[];drive(c=>{calls.push(c);return c.operation==='view'?{data:'Zm9v',width:1280,height:800}:{ok:true}});const t=await take(),f=await frame(),body={controlId:t.controlId,token:t.token,requestId:randomUUID(),generation:f.generation,frameId:f.id,action:{kind:'click',x:10,y:10}};await request(app()).post(base()+'/computer/input').send({...body,frameId:randomUUID()}).expect(409);await request(app()).post(base()+'/computer/input').send(body).expect(200);await request(app()).post(base()+'/computer/input').send(body).expect(200);expect(calls.filter(c=>c.operation==='input')).toHaveLength(1);await request(app()).post(base()+'/computer/input').send({...body,action:{kind:'text',text:'different'}}).expect(409);await request(app()).put(base()+'/browser-profile').send({profile:'temporary'}).expect(409)})
it('expired control remains paused until a new takeover is explicitly returned',async()=>{drive();const t=await take();const original=Date.now;const time=vi.spyOn(Date,'now').mockImplementation(()=>original()+31000);service.exchange({host,results:[]});await request(app()).post(base()+'/computer/renew').send(t).expect(410);expect((await request(app()).get(base()+'/computer')).body.mode).toBe('error');time.mockRestore();const next=await take();await request(app()).post(base()+'/computer/giveback').send({...next,notes:'已完成登录'}).expect(200);expect((await request(app()).get(base()+'/computer')).body.mode).toBe('idle')})
it('pins tool calls to the host epoch and does not dispatch after permissions change',async()=>{drive();const epoch=service.epoch,signal=new AbortController().signal;await service.call('owner',agent.id,'desktop_environment_view',{},signal,()=>{},'browser',epoch);host.id=randomUUID();service.exchange({host,results:[]});await expect(service.call('owner',agent.id,'desktop_environment_action',{kind:'text',text:'no'},signal,()=>{},'browser',epoch)).rejects.toThrow('连接已改变');version++;const t=await take();version++;await request(app()).post(base()+'/computer/renew').send(t).expect(410)})
it('waits for human release before the robot runs and forwards handoff notes',async()=>{drive();const t=await take();let complete=false;const call=service.call('owner',agent.id,'desktop_environment_view',{},new AbortController().signal,()=>{},'browser',service.epoch).then(value=>{complete=true;return value});await new Promise(resolve=>setTimeout(resolve,30));expect(complete).toBe(false);await request(app()).post(base()+'/computer/giveback').send({...t,notes:'已登录测试账号'}).expect(200);const value=await call;expect(JSON.stringify(value)).toContain('已登录测试账号')})
it('refuses dangerous navigation and prevents changing profile during active work',async()=>{drive();const t=await take(),f=await frame();await request(app()).post(base()+'/computer/browser').send({controlId:t.controlId,token:t.token,requestId:randomUUID(),generation:f.generation,frameId:f.id,action:{kind:'navigate',url:'file:///etc/passwd'}}).expect(400);await request(app()).post(base()+'/computer/giveback').send(t).expect(200);store.put('owner','turn','turn',{agentId:agent.id,status:'running'});await request(app()).put(base()+'/browser-profile').send({profile:'temporary'}).expect(409)})