yaoyao/tests/server/managedBrowserSmoke.test.ts

// @vitest-environment node
import {expect,it,vi} from 'vitest'
import Koa from 'koa'
import {bodyParser} from '@koa/bodyparser'
import {createServer,type Server} from 'node:http'
import {mkdtempSync,realpathSync,rmSync} from 'node:fs'
import {tmpdir} from 'node:os'
import {join} from 'node:path'
import {randomUUID} from 'node:crypto'
import {WorkspaceStore} from '../../src/server/workspaceStore'
import {LocalAuthStore} from '../../src/server/localAuth'
import {WorkspaceNodes,type GatewayTarget} from '../../src/server/workspaceGateway'
import {loadServerConfig} from '../../src/server/config'
import {saveHostTools} from '../../src/server/hostToolSettings'
import {RunnerHub} from '../../src/server/runnerHub'
import {RunnerAgent} from '../../src/runner/agent'
import {ManagedBrowsers,type BrowserTurn} from '../../src/server/managedBrowsers'
import {HttpError} from '../../src/server/errors'
import type {RunnerConfiguration} from '../../src/shared/runner'

class FixtureAuth extends LocalAuthStore {
  version=1
  override isUserActive(){return true}
  override pushAuthorizationVersion(){return this.version}
  override canUseSource(){return true}
  override require(){return {id:'owner',username:'fixture',role:'admin'} as ReturnType<LocalAuthStore['require']>}
}
const listen=(server:Server)=>new Promise<string>(resolve=>server.listen(0,'127.0.0.1',()=>resolve(`http://127.0.0.1:${(server.address() as {port:number}).port}`)))
const close=(server:Server)=>new Promise<void>(resolve=>{server.close(()=>resolve());server.closeAllConnections()})

/** YAOYAO_BROWSER_SMOKE=1 npx vitest run tests/server/managedBrowserSmoke.test.ts
 * Real outbound Runner protocol and Chromium; about:blank avoids website access.
 * The Hermes HTTP fixture never opens a model session or a computer Worker. */
it.skipIf(process.env.YAOYAO_BROWSER_SMOKE!=='1')('uses a browser-only Runner through authenticated HTTP, UI takeover and the same task session',async()=>{
  const home=realpathSync(mkdtempSync(join(tmpdir(),'yaoyao-browser-http-smoke-'))),store=new WorkspaceStore(home),auth=new FixtureAuth(home)
  saveHostTools(home,{managedBrowser:true,vm:false,scriptMachine:false,serverComputer:false,cloud:false})
  let hermesRequests=0
  const hermes=createServer((_req,res)=>{hermesRequests++;res.setHeader('Content-Type','application/json');res.end(JSON.stringify({ok:true,auth_required:false}))})
  const hermesURL=await listen(hermes)
  const target={url:new URL(hermesURL)} as GatewayTarget
  const nodes=new WorkspaceNodes(store,loadServerConfig({HERMES_YAOYAO_HOME:home}),target)
  nodes.sourceAllowed=(owner,node,profile)=>auth.canUseSource()
  const hub=new RunnerHub(store,auth,target),service=new ManagedBrowsers(store,auth,nodes,hub)
  hub.browserAllowed=(runnerId,scope,grantId)=>service.allowed(runnerId,scope,grantId)
  const registered=hub.enroll('owner',{name:'浏览器专用节点',allowedProfiles:['default']})
  const app=new Koa(),requests:string[]=[],checks:boolean[]=[]
  app.use(async(ctx,next)=>{
    requests.push(ctx.path)
    try{await next()}catch(error){ctx.status=error instanceof HttpError?error.status:500;ctx.body={code:(error as any).code,error:error instanceof Error?error.message:'Failed'}}
    if(ctx.path.endsWith('/browser-check'))checks.push((ctx.body as any)?.allowed===true)
  })
  // RunnerHub reads its authenticated machine JSON directly; keep bodyParser
  // after it, matching production router order.
  app.use(hub.middleware());app.use(bodyParser());const router=service.router();app.use(router.routes());app.use(router.allowedMethods())
  const web=createServer(app.callback()),serverURL=await listen(web)
  const config:RunnerConfiguration={protocol:1,serverURL,runnerId:registered.runner.id,token:registered.token,hermesURL,allowedProfiles:['default'],artifactRoots:[],browser:{enabled:true}}
  const status:string[]=[],runner=new RunnerAgent(config,home,fetch,message=>status.push(message)),controller=new AbortController()
  const running=runner.run(controller.signal);void running.catch(()=>{})
  let task:BrowserTurn|undefined
  const ui=async(path:string,body?:unknown)=>{
    const response=await fetch(serverURL+path,{method:body===undefined?'GET':'POST',headers:{'Content-Type':'application/json'},...(body===undefined?{}:{body:JSON.stringify(body)})})
    const value=await response.json() as any
    expect(response.status,JSON.stringify(value)).toBe(200)
    return value
  }
  try{
    await vi.waitFor(()=>expect(hub.summary(hub.records()[0]!).features).toContain('managed-browser-v1'),{timeout:35000,interval:50})
    await vi.waitFor(()=>expect(status).toContain('执行节点已连接'))
    const features=hub.summary(hub.records()[0]!).features
    expect(features).not.toContain('computer-worker-v1');expect(features).not.toContain('computer-control-v1')
    expect(config.computers).toBeUndefined()
    const agent=store.createAgent('owner',{name:'浏览器任务',profile:'default'}),base=`/api/app/agents/${agent.id}`
    expect(await ui(base+'/managed-browser')).toMatchObject({enabled:true,available:true,open:false})
    const taskController=new AbortController()
    task=service.openTurn('owner',agent,{workId:randomUUID(),signal:taskController.signal,authorize:()=>taskController.signal.throwIfAborted(),publish:async()=>{throw new Error('No download in this smoke')},upload:async()=>{throw new Error('No upload in this smoke')}})
    const opened=await task.call('managed_browser_open',{},'open') as any
    expect(opened.open).toBe(true);expect(opened.tabs).toHaveLength(1);expect(opened.tabs[0].url).toBe('about:blank')
    const before=await task.call('managed_browser_state',{},'state-before') as any
    const shot=await task.call('managed_browser_action',{action:{kind:'screenshot'}},'screenshot') as any
    expect(shot.content[0].mimeType).toBe('image/png')
    expect(Buffer.from(shot.content[0].data,'base64').subarray(1,4).toString()).toBe('PNG')
    const taken=await ui(base+'/computer/take?backend=managed-browser',{requestId:randomUUID()})
    expect(taken).toMatchObject({backend:'managed-browser',mode:'human',canResume:true})
    expect(taken.generation).toBeGreaterThan(before.generation)
    const credentials={controlId:taken.controlId,token:taken.token}
    const frame=await ui(base+'/computer/frame?backend=managed-browser')
    expect(frame).toMatchObject({generation:taken.generation,width:1280,height:800})
    await ui(base+'/computer/input?backend=managed-browser',{...credentials,requestId:randomUUID(),generation:frame.generation,frameId:frame.id,action:{kind:'key',key:'Tab'}})
    let completed=false
    const waiting=task.call('managed_browser_state',{},'state-after').finally(()=>{completed=true})
    await new Promise(resolve=>setTimeout(resolve,30));expect(completed).toBe(false)
    await ui(base+'/computer/giveback?backend=managed-browser',{...credentials,notes:'可以继续'})
    const resumed=await waiting as any
    expect(resumed.humanNote).toBe('可以继续')
    expect(resumed.result.tabs[0].id).toBe(before.tabs[0].id)
    expect(resumed.result.generation).toBeGreaterThan(taken.generation)
    await task.close();task=undefined
    expect(await ui(base+'/managed-browser')).toMatchObject({open:false,available:true})
    for(const endpoint of ['poll','admit','result','browser-check'])expect(requests.some(path=>path.endsWith('/'+endpoint))).toBe(true)
    expect(checks.length).toBeGreaterThan(10);expect(checks.every(Boolean)).toBe(true)
    expect(hermesRequests).toBe(0)
  }finally{
    await task?.close().catch(()=>{})
    controller.abort();await running.catch(()=>{})
    service.close();hub.close();nodes.close()
    await close(web);await close(hermes)
    store.close();rmSync(home,{recursive:true,force:true})
  }
},60000)