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.

5.3 KB
Raw Blame
import { afterEach, describe, expect, it } from 'vitest'
import { chmodSync, existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { GridFleetRpc, GridOutputCapture, parseGridFleetRequest } from './gridFleetRpc.js'
import { withGridCallsPaused } from './gridCalls.js'
import { encryptDownFrame, encryptRpcResult } from './e2ee/applicationFrames.js'

const directories: string[] = []
afterEach(() => { for (const directory of directories.splice(0)) rmSync(directory, { recursive: true, force: true }) })
function fixture(body: string) {
  const dir = mkdtempSync(join(tmpdir(), 'grid-fleet-rpc-')); directories.push(dir)
  const file = join(dir,'grid'); writeFileSync(file,`#!${process.execPath}\n${body}\n`); chmodSync(file,0o700)
  return new GridFleetRpc({ ...process.env, HARNESS_GRID_BIN: file })
}
describe('paired Grid fleet commands', () => {
  it('validates bounded argv and runtime, rejecting NULs and command strings', () => {
    expect(parseGridFleetRequest({args:['--remote','chat','a prompt\nwith lines']})).toEqual({args:['--remote','chat','a prompt\nwith lines'],timeoutMs:30000})
    for (const payload of [{args:'grid ls'},{args:[]},{args:['x\0y']},{args:['x'.repeat(17000)]},{args:['ls'],timeoutMs:1_800_001},{args:['ls'],timeoutMs:-1}]) expect(parseGridFleetRequest(payload)).toBeNull()
  })
  it('preserves argument boundaries and exit status without shell interpretation', async () => {
    const rpc=fixture('console.log(JSON.stringify(process.argv.slice(2)));process.exit(7)')
    const args=['--local','chat','$(echo secret); `pwd`',"single'quote",'line\nline']
    const result=await rpc.run('owner','one',{args,timeoutMs:3000})
    expect(result.code).toBe(7);expect(result.ok).toBe(false);expect(JSON.parse(result.stdout)).toEqual(args)
  })
  it('waits while an install holds grid calls back (gridCalls.ts)', async () => {
    const started=join(mkdtempSync(join(tmpdir(), 'grid-fleet-started-')), 'started')
    const rpc=fixture(`require('node:fs').writeFileSync(${JSON.stringify(started)}, '');process.exit(0)`)
    let finish: () => void = () => {}
    const install=withGridCallsPaused(() => new Promise<void>((resolve) => { finish = resolve }))
    const call=rpc.run('owner','paused',{args:['ls'],timeoutMs:10_000})
    // A Node child takes about half a second to start on a busy Mac: give it well over that.
    await new Promise((resolve) => setTimeout(resolve, 2_000))
    expect(existsSync(started)).toBe(false)
    finish(); await install
    expect((await call).ok).toBe(true)
    expect(existsSync(started)).toBe(true)
  })
  it('keeps timeout failures even when a child handles SIGTERM with exit zero', async () => {
    const rpc=fixture("process.on('SIGTERM',()=>process.exit(0));setInterval(()=>{},1000)")
    const result=await rpc.run('owner','timeout',{args:['join'],timeoutMs:200})
    expect(result).toMatchObject({ok:false,code:124});expect(result.error).toContain('timed out')
  })
  it('applies explicit thinking to this child only, without allowing arbitrary environment input', async () => {
    expect(parseGridFleetRequest({args:['join'],thinking:'off'})).toBeNull()
    const rpc=fixture("console.log(process.env.LLAMA_ARG_CHAT_TEMPLATE_KWARGS || 'unset')")
    expect((await rpc.run('owner','off',{args:['join'],timeoutMs:3000,thinking:false})).stdout.trim()).toBe('{"enable_thinking":false}')
    expect((await rpc.run('owner','default',{args:['join'],timeoutMs:3000})).stdout.trim()).toBe('unset')
  })
  it('owns cancellation by connection and refuses duplicate live requests', async () => {
    const rpc=fixture('setInterval(()=>{},1000)')
    const pending=rpc.run('owner','job',{args:['pull'],timeoutMs:5000})
    expect(rpc.cancel('stranger','job')).toBe(false)
    expect((await rpc.run('owner','job',{args:['pull'],timeoutMs:5000})).error).toContain('already running')
    expect(rpc.cancel('owner','job')).toBe(true)
    expect(await pending).toMatchObject({ok:false,code:124})
  })
  it('fails loud on oversized output instead of returning a truncated successful JSON result', async () => {
    const result=await fixture("process.stdout.write('x'.repeat(600000));setInterval(()=>{},1000)").run('owner','large',{args:['models'],timeoutMs:3000})
    expect(result).toMatchObject({ok:false,code:124});expect(result.error).toContain('512 KiB')
  })
  it('keeps download progress bounded while retaining completed diagnostics', async () => {
    const output=new GridOutputCapture()
    output.append('Downloading model\n\rfirst');output.append('\r');output.append('last\r');output.append('\nDone\n')
    expect(output.text).toBe('Downloading model\nlast\nDone\n')
    const result=await fixture("for(let i=0;i<50000;i++)process.stderr.write('\\r['+i+'/50000] downloading model');console.log('saved model.gguf')").run('owner','progress',{args:['pull'],timeoutMs:10000})
    expect(result).toMatchObject({ok:true,code:0});expect(result.stdout).toBe('saved model.gguf\n')
    expect(result.stderr).toBe('[49999/50000] downloading model')
  })
  it('requires pairwise encryption in both directions for every fleet RPC', () => {
    for(const type of ['grid_fleet_capabilities','grid_fleet_run','grid_fleet_cancel']) {
      expect(encryptDownFrame(type)).toBe(true);expect(encryptRpcResult(`${type}_result`)).toBe(true)
    }
  })
})