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.

17.5 KB
Raw Blame
import { afterEach, describe, expect, it } from 'vitest'
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { classifyGridAssignment, probeGridAssignment, readOpencodeGridAssignment, readPiGridAssignment } from './gridAssignment.js'
import { gridAssignmentProcess } from './gridAssignmentWire.js'
import { buildGridEngineLaunch, gridCapableEngines, gridConfigHandOff, type GridLaunchOverride } from './gridLaunch.js'
import type { AgentEngine } from '../engines/types.js'
import { clearProcessEnvCache, parsePsEnviron } from './processEnv.js'

const NETWORK_ID = 'grid-3378218621364f16'
const RELAY = `https://grid.autonomous.ai/${NETWORK_ID}/relay`
const RELAY_V1 = `${RELAY}/v1`

const OVERRIDE: GridLaunchOverride = {
  networkId: NETWORK_ID,
  networkName: 'autonomous.ai',
  baseUrl: RELAY_V1,
  apiKey: 'gridkey-secret',
  model: 'GLM-4.7-Flash',
}

/** The same launch with the grid's web tools wired in — see `gridLaunch`'s MCP section. */
const WITH_MCP: GridLaunchOverride = {
  ...OVERRIDE,
  mcpUrl: 'https://api-grid.autonomous.ai/v1/grid/web-mcp/',
}

describe('classifyGridAssignment', () => {
  it('reads back what every supported engine was actually launched with', () => {
    // The point of the round trip: the probe and the launcher must use the SAME knob per engine, or
    // an agent that IS on a grid reports as being on none and gets pointlessly restarted.
    for (const engine of gridCapableEngines()) {
      // Pi and OpenCode keep their endpoint in a file rather than in the process, so they
      // round-trip through their own probes below — this one only covers what a process carries.
      if (engine === 'pi' || engine === 'opencode') continue
      const built = buildGridEngineLaunch(engine, OVERRIDE, { hermesSystemManaged: false })
      expect(built.ok).toBe(true)
      if (!built.ok) continue
      const assignment = classifyGridAssignment(engine, built.launch.env, built.launch.args.join(' '))
      expect(assignment, engine).not.toBeNull()
      expect(assignment?.baseUrl, engine).toContain(NETWORK_ID)
      expect(assignment?.model, engine).toBe('GLM-4.7-Flash')
    }
  })

  it('never carries the credential out of the process', () => {
    for (const engine of gridCapableEngines()) {
      if (engine === 'pi' || engine === 'opencode') continue
      const built = buildGridEngineLaunch(engine, OVERRIDE, { hermesSystemManaged: false })
      if (!built.ok) continue
      const assignment = classifyGridAssignment(engine, built.launch.env, built.launch.args.join(' '))
      expect(JSON.stringify(assignment), engine).not.toContain('gridkey-secret')
    }
  })

  it('leaves an agent the user pointed somewhere else alone', () => {
    // Offering to "move" these away from where they were deliberately sent would be the app
    // overruling a choice it did not make.
    expect(classifyGridAssignment('claude', { ANTHROPIC_BASE_URL: 'https://openrouter.ai/api' })).toBeNull()
    expect(classifyGridAssignment('opencode', { OPENAI_BASE_URL: 'http://localhost:8080/v1' })).toBeNull()
    expect(classifyGridAssignment('claude', {})).toBeNull()
    expect(classifyGridAssignment('claude', { ANTHROPIC_BASE_URL: '   ' })).toBeNull()
    expect(classifyGridAssignment('claude', { ANTHROPIC_BASE_URL: 'not a url' })).toBeNull()
  })

  it('reads Codex off its argv, where its endpoint actually lives', () => {
    const args = `codex -c model_provider="grid" -c model_providers.grid.base_url="${RELAY_V1}" -m GLM-4.7-Flash`
    expect(classifyGridAssignment('codex', { GRID_API_KEY: 'gridkey-secret' }, args))
      .toEqual({ baseUrl: RELAY_V1, model: 'GLM-4.7-Flash' })
    // Its environment alone says nothing — reading only env would report every codex agent as free.
    expect(classifyGridAssignment('codex', { GRID_API_KEY: 'gridkey-secret' })).toBeNull()
  })

  it('reads Grok\'s argv model, and reports the router as no model at all', () => {
    const env = { GROK_MODELS_BASE_URL: RELAY_V1, GRID_API_KEY: 'gridkey-secret' }
    expect(classifyGridAssignment('grok', env, 'grok -m DeepSeek-V4-Flash-0731'))
      .toEqual({ baseUrl: RELAY_V1, model: 'DeepSeek-V4-Flash-0731' })
    // ⚠️ Grok ALWAYS carries `-m`, unlike codex: its grid credential rides on a declared model block,
    // so "let the grid route" is spelled `-m Auto` rather than by omitting the flag. Reporting that id
    // verbatim would print `Auto` where the app prints its own Auto row from null, and a check that the
    // agent is where the person put it would compare 'Auto' against null and call every routed agent
    // misplaced, forever — the same trap opencode's reader documents.
    expect(classifyGridAssignment('grok', env, 'grok -m Auto'))
      .toEqual({ baseUrl: RELAY_V1, model: null })
  })

  it('does not confuse one engine\'s knob for another\'s', () => {
    // A grok agent whose OPENAI_BASE_URL happens to be set by the user's shell is not on a grid.
    expect(classifyGridAssignment('grok', { OPENAI_BASE_URL: RELAY_V1 })).toBeNull()
    expect(classifyGridAssignment('copilot', { ANTHROPIC_BASE_URL: RELAY })).toBeNull()
  })

  it('reads a real macOS `ps eww` line, which is how this actually arrives', () => {
    const line = `/Users/u/.local/bin/claude --resume abc ANTHROPIC_BASE_URL=${RELAY}`
      + ' ANTHROPIC_AUTH_TOKEN=gridkey-secret ANTHROPIC_MODEL=GLM-4.7-Flash HOME=/Users/u'
    expect(classifyGridAssignment('claude', parsePsEnviron(line)))
      .toEqual({ baseUrl: RELAY, model: 'GLM-4.7-Flash' })
  })

  it('has no answer for an engine that cannot be on a grid at all', () => {
    expect(classifyGridAssignment('cursor', { ANTHROPIC_BASE_URL: RELAY })).toBeNull()
  })
})

describe('Pi, whose endpoint lives in a file', () => {
  const dirs: string[] = []
  afterEach(() => {
    clearProcessEnvCache()
    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true })
  })

  /** Writes the launch's own files where the probe will look for them, and the argv the pane runs. */
  function materialize(): { dir: string; args: string } {
    const built = buildGridEngineLaunch('pi', OVERRIDE, { hermesSystemManaged: false })
    if (!built.ok) throw new Error(built.detail)
    const dir = mkdtempSync(join(tmpdir(), 'pi-grid-'))
    dirs.push(dir)
    for (const file of built.launch.configDir!.files) writeFileSync(join(dir, file.name), file.content)
    const handOff = gridConfigHandOff(built.launch.configDir!, dir)
    return { dir, args: `pi --session 01a1387c-b029-75b7-b0f0-925d65eb8121 ${[...built.launch.args, ...handOff.args].join(' ')}` }
  }

  it('round-trips: what the launcher wrote is what the probe reads back', async () => {
    const { args } = materialize()
    // Parsed from a real macOS `ps eww` line — argv first, then the environment — so the shape the
    // probe is handed at runtime is the shape under test.
    const env = parsePsEnviron(`${args} GRID_API_KEY=gridkey-secret`)
    await expect(readPiGridAssignment(env, args)).resolves.toEqual({
      baseUrl: RELAY_V1,
      model: 'GLM-4.7-Flash',
    })
    // And the process the core hands the models service carries the extension and model, nothing else of argv.
    expect(gridAssignmentProcess('k', 'pi', env, args)?.args).toBe(`-e ${args.split(' -e ')[1]} --model grid/GLM-4.7-Flash`)
  })

  it('an extension that is gone reads as unknown, not as fine', async () => {
    const { dir, args } = materialize()
    rmSync(dir, { recursive: true, force: true })
    // Nothing to read → null → the app offers a move rather than claiming the agent is in place.
    await expect(readPiGridAssignment({}, args)).resolves.toBeNull()
  })

  it('reads nothing when the pane was never given the extension', async () => {
    expect(gridAssignmentProcess('k', 'pi', {}, 'pi --model grid/GLM-4.7-Flash')).toBeNull()
    await expect(readPiGridAssignment({}, 'pi --model grid/GLM-4.7-Flash')).resolves.toBeNull()
  })

  it('will not call a provider pointed somewhere else a grid', async () => {
    const { dir, args } = materialize()
    const file = join(dir, 'grid-provider.ts')
    writeFileSync(file, readFileSync(file, 'utf8').replace(RELAY_V1, 'https://api.openai.com/v1'))
    await expect(readPiGridAssignment({}, args)).resolves.toBeNull()
  })

  it('still reads a Pi launched before the extension, from the config directory it was moved into', async () => {
    // Such a Pi keeps running until it is next relaunched, and the app must not call it off its grid meanwhile.
    const dir = mkdtempSync(join(tmpdir(), 'pi-grid-old-'))
    dirs.push(dir)
    writeFileSync(join(dir, 'models.json'), JSON.stringify({ providers: { grid: { baseUrl: RELAY_V1 } } }))
    const args = 'pi --model grid/GLM-4.7-Flash'
    const env = parsePsEnviron(`${args} PI_CODING_AGENT_DIR=${dir}`)
    expect(gridAssignmentProcess('k', 'pi', env, args)).not.toBeNull()
    await expect(readPiGridAssignment(env, args)).resolves.toEqual({ baseUrl: RELAY_V1, model: 'GLM-4.7-Flash' })
  })
})

describe('readOpencodeGridAssignment', () => {
  const dirs: string[] = []
  afterEach(() => {
    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true })
  })

  // OpenCode's endpoint lives in the config file this daemon wrote, not in a variable. Two
  // regressions are pinned here:
  //  * listing opencode under BASE_URL_VAR while its endpoint had moved made every opencode agent
  //    report "own login" while the grid answered correctly underneath;
  //  * reading the model out of argv made the app's pill flicker between the model and "own login"
  //    while the agent was answering, because a live process may rewrite its command line.
  const RELAY = 'https://grid.autonomous.ai/grid-3378218621364f16/relay/v1'
  const write = (body: unknown): string => {
    const dir = mkdtempSync(join(tmpdir(), 'harness-opencode-cfg-'))
    dirs.push(dir)
    const path = join(dir, 'opencode.json')
    writeFileSync(path, JSON.stringify(body))
    return path
  }
  const config = (baseURL: string, models: string[] = ['DeepSeek-V4-Flash-0731']) => ({
    provider: {
      'autonomous-ai': {
        npm: '@ai-sdk/openai-compatible',
        options: { baseURL },
        models: Object.fromEntries(models.map((m) => [m, { name: m }])),
      },
    },
  })

  it('round-trips the config the LAUNCHER writes, not one written by hand', async () => {
    // The strongest form of this test: build the real launch, write its real files where the probe
    // will look, and read them back. A spec that hand-writes the config proves only that two
    // hand-written shapes agree.
    const built = buildGridEngineLaunch('opencode', OVERRIDE, { hermesSystemManaged: false })
    if (!built.ok) throw new Error(built.detail)
    const dir = mkdtempSync(join(tmpdir(), 'opencode-grid-'))
    dirs.push(dir)
    for (const file of built.launch.configDir!.files) {
      writeFileSync(join(dir, file.name), file.content)
    }
    const assignment = await readOpencodeGridAssignment({
      [built.launch.configDir!.envVar!]: join(dir, built.launch.configDir!.pointAt!),
    })
    expect(assignment).not.toBeNull()
    expect(assignment!.baseUrl).toContain(NETWORK_ID)
    expect(assignment!.model).toBe(OVERRIDE.model)
    // And the credential never leaves the process, exactly as for every other engine.
    expect(JSON.stringify(assignment)).not.toContain('gridkey-secret')
  })

  it('reports the router as NO model, the way every other engine does', async () => {
    // OpenCode is the only engine whose provider block must name something, so a launch with no
    // model picked writes the relay's router id there. Letting that id back out would be the app's
    // own "Auto" under a second name: the header would print the raw id, and a check that the agent is
    // where the person put it would compare it against null and call every such agent mis-targeted forever.
    const path = write(config(RELAY, ['Auto']))
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: path }))
      .resolves.toEqual({ baseUrl: RELAY, model: null })
  })

  it('answers the same whatever the engine has done to its command line', async () => {
    // The flicker: argv is a live process's to rewrite, so nothing here may depend on it.
    const path = write(config(RELAY))
    const expected = { baseUrl: RELAY, model: 'DeepSeek-V4-Flash-0731' }
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: path })).resolves.toEqual(expected)
  })

  it('answers null for an endpoint that is not a relay', async () => {
    const path = write(config('https://api.openai.com/v1'))
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: path })).resolves.toBeNull()
  })

  it('answers null for a file this launch did not write', async () => {
    // A user's own config can carry several providers; guessing which one an engine would pick
    // would report an agent as being on a grid it is not on.
    const path = write({
      provider: {
        'autonomous-ai': { options: { baseURL: RELAY }, models: { a: {} } },
        other: { options: { baseURL: RELAY } },
      },
    })
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: path })).resolves.toBeNull()
  })

  it('answers null when the provider names more than one model', async () => {
    // Then the file cannot say which one is live, and a guess would be reported as a measurement.
    const path = write(config(RELAY, ['DeepSeek-V4-Flash-0731', 'Auto']))
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: path })).resolves.toBeNull()
  })

  it('answers null rather than throwing when the file is gone or unreadable', async () => {
    await expect(readOpencodeGridAssignment({ OPENCODE_CONFIG: '/nonexistent/opencode.json' }))
      .resolves.toBeNull()
    await expect(readOpencodeGridAssignment({})).resolves.toBeNull()
  })
})

describe('a failed read is not a finding', () => {
  // The flicker this pins: the app's grid pill swapped between an agent's model and "own login" for
  // the length of every turn. Each probe whose `ps` did not answer in time reported "on no grid",
  // the registry wrote that over a known-good assignment, and the next successful probe put it back.
  //
  // The distinction is the fix, not the failure rate. A read can fail for reasons this code will
  // never enumerate — a busy machine, a 2s timeout, a process caught mid-exec — and none of them are
  // evidence about where an agent is pointed.
  const DEAD_PID = 2 ** 31 - 1

  it('answers undefined when the environment cannot be read at all', async () => {
    clearProcessEnvCache()
    await expect(probeGridAssignment(
      { pid: DEAD_PID, executable: 'opencode', startMarker: 'Mon Jan  1 00:00:00 2035' },
      'opencode',
    )).resolves.toBeUndefined()
  })

  it('is distinguishable from a read that found no grid', () => {
    // Same call shape, opposite meaning: this one looked and there was nothing.
    expect(classifyGridAssignment('claude', { PATH: '/usr/bin' })).toBeNull()
    // `null == undefined` is true, so only a strict check tells these apart — which is exactly what
    // `openProcessAgent` and `updateProcessIdentity` do.
    expect(classifyGridAssignment('claude', { PATH: '/usr/bin' })).not.toBeUndefined()
  })
})

describe('web tools do not disturb the probe', () => {
  // Wiring MCP adds argv to Codex and a key to OpenCode's config file, and both are things the probe
  // parses. An agent that IS on a grid reporting as being on none gets pointlessly restarted, so the
  // round trips above are repeated against the shape a launch with web tools produces.
  const dirs: string[] = []
  afterEach(() => {
    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true })
  })

  const classify = (engine: AgentEngine, override: GridLaunchOverride) => {
    const built = buildGridEngineLaunch(engine, override, { hermesSystemManaged: false })
    if (!built.ok) throw new Error(`${engine}: ${built.detail}`)
    return classifyGridAssignment(engine, built.launch.env, built.launch.args.join(' '))
  }

  it('reads a process back identically with the MCP argv in the way', () => {
    for (const engine of gridCapableEngines()) {
      if (engine === 'pi' || engine === 'opencode') continue
      // Compared against the same engine launched WITHOUT web tools rather than a literal, so this
      // states the invariant — wiring MCP changes nothing the probe reads — in a form that survives
      // an engine changing which URL shape it wants.
      expect(classify(engine, WITH_MCP), engine).toEqual(classify(engine, OVERRIDE))
      expect(classify(engine, WITH_MCP)?.model, engine).toBe('GLM-4.7-Flash')
    }
  })

  it('never reads the control plane as the place an agent is running', () => {
    // Codex is the one at risk: its endpoint comes out of argv, which now also carries
    // `mcp_servers.harness.url=…`. Reading that as the endpoint would report an agent as running on
    // the control plane, and the app would offer to move it off a grid it is already on.
    expect(classify('codex', WITH_MCP)?.baseUrl).toBe(RELAY_V1)
  })

  it("reads OpenCode's config back with the server declared beside the provider", async () => {
    const built = buildGridEngineLaunch('opencode', WITH_MCP, { hermesSystemManaged: false })
    if (!built.ok) throw new Error(built.detail)
    const dir = mkdtempSync(join(tmpdir(), 'opencode-grid-mcp-'))
    dirs.push(dir)
    for (const file of built.launch.configDir!.files) {
      writeFileSync(join(dir, file.name), file.content)
    }
    const assignment = await readOpencodeGridAssignment({
      [built.launch.configDir!.envVar!]: join(dir, built.launch.configDir!.pointAt!),
    })
    expect(assignment).toEqual({ baseUrl: RELAY_V1, model: 'GLM-4.7-Flash' })
  })
})