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.

7.7 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { tmpdir } from 'node:os'
import { randomUUID } from 'node:crypto'
import type { RegisteredSession } from '../registry.js'
import type { DshRegistryEntry } from '../../dsh/registry.js'
const state = vi.hoisted(() => ({ agents: [] as RegisteredSession[], catalog: [] as DshRegistryEntry[] }))
// The core's registry, as the core's Wi-Fi doors read it (core/wifiAgents.ts): the Store runs with the device's
// service, in the devices' process, and reads the agents and makes one through them.
const registry = { list: () => state.agents, advertised: () => state.agents, terminalAvailable: () => true }
const deviceStoreAgents = (machineId: string) => storeAgents({ registry, machineId: () => machineId })
vi.mock('../../dsh/catalog.js', () => ({ refreshDshRegistry: async () => state.catalog, catalogEntry: (id: string) => state.catalog.find(e => e.id === id) }))
import { env } from '../../config/env.js'
import * as engineLaunch from '../engineLaunch.js'
import { installDsh } from '../../dsh/install.js'
import { installedDsh, invalidateInstalledDsh } from '../../dsh/installed.js'
import { materializeWorkspace } from '../../dsh/materialize.js'
import { createDeviceStore, deviceStorePackages } from './storeRuntime.js'
import { storeAgents, wifiCreate } from '../../core/wifiAgents.js'
import { DeviceStoreResultSchema } from './storeContract.js'
import { HARNESS_MONOREPO } from '../../dsh/registry.js'

let root: string, original: string
beforeEach(() => {
  root = realpathSync(mkdtempSync(join(tmpdir(), 'device-store-runtime-')))
  original = env.DSH_DIR; env.DSH_DIR = join(root, 'installed'); invalidateInstalledDsh()
  state.agents = []; state.catalog = []
  // Run real fixture shell scripts, without sourcing the operator's login profile.
  vi.spyOn(engineLaunch, 'interactiveEngineShell').mockReturnValue(null)
})
afterEach(() => { vi.restoreAllMocks(); env.DSH_DIR = original; invalidateInstalledDsh(); rmSync(root, { recursive: true, force: true }) })
async function setup() {
  const source = join(root, 'package'); mkdirSync(join(source, 'template'), { recursive: true })
  writeFileSync(join(source, 'harness.json'), JSON.stringify({ spec: 1, id: 'test/robot-fixture', name: 'Robot fixture', engine: 'claude',
    toolchain: { setup: 'setup.sh', doctor: 'doctor.sh' }, workspace: { template: 'template', marker: 'scene.txt' }, agent: { instructions: 'AGENTS.md' } }))
  writeFileSync(join(source, 'setup.sh'), '#!/bin/sh\nprintf installed > dependency\n', { mode: 0o755 })
  writeFileSync(join(source, 'doctor.sh'), '#!/bin/sh\nif [ -f dependency ]; then echo "ok dependency"; else echo "miss dependency"; exit 1; fi\n', { mode: 0o755 })
  writeFileSync(join(source, 'AGENTS.md'), 'Fixture instructions, no model calls.\n')
  writeFileSync(join(source, 'template', 'scene.txt'), 'fixture scene\n')
  const installed = await installDsh({ source, link: true })
  expect(installed.ok).toBe(true)
  const cwd = join(root, 'workspace'); mkdirSync(cwd)
  const create = vi.fn(async (input: Parameters<NonNullable<import('../../backendSocket.js').BackendSocket['onCreateAgent']>>[0]) => {
    await materializeWorkspace(installedDsh(input.dsh!)!, input.cwd)
    const session = { agentId: 'fixture-agent', sessionId: 'native-conversation', active: true, cwd: input.cwd, dsh: input.dsh, engine: input.engine, launch: { state: 'ready' } } as RegisteredSession
    state.agents.push(session)
    return { ok: true as const, session }
  })
  const store = createDeviceStore({ dataDir: join(root, 'state'), machineId: 'mac', agents: () => deviceStoreAgents('mac'),
    create: wifiCreate({ registry, machineId: () => 'mac', createAgent: () => create }) })
  const request = { type: 'agent.prepare', requestId: randomUUID(), machineId: 'mac', packageId: 'test/robot-fixture', workspace: { kind: 'existing', path: cwd }, idempotencyKey: 'prepare' }
  return { source, cwd, create, store, request }
}
describe('device Store production adapter with real local package scripts', () => {
  it('accepts confirmed launch readiness before the first native conversation exists', () => {
    const session = { agentId: 'fresh', sessionId: '', active: true, engine: 'claude', cwd: root,
      dsh: null, launch: { state: 'ready' } } as RegisteredSession
    state.agents = [session]
    expect(deviceStoreAgents('mac')[0].runtime).toBe('ready')
    session.launch = { state: 'starting' }
    expect(deviceStoreAgents('mac')[0].runtime).toBe('starting')
    session.launch = { state: 'failed', error: 'ENGINE_FAILED' }
    expect(deviceStoreAgents('mac')[0].runtime).toBe('unavailable')
    session.launch = undefined
    expect(deviceStoreAgents('mac')[0].runtime).toBe('starting')
  })
  it('uses actual installed inventory, doctor and materialization with safe creation arguments', async () => {
    const f = await setup()
    const reply = await f.store.request('lamp', f.request)
    const id = (reply.operation as { operationId: string }).operationId
    await vi.waitFor(() => expect(f.store.get('lamp', id).state).toBe('ready'))
    expect(f.store.get('lamp', id).doctor).toEqual(['test/robot-fixture: ok dependency'])
    expect(f.create).toHaveBeenCalledWith(expect.objectContaining({ cwd: f.cwd, dsh: 'test/robot-fixture', prompt: null, bypassPermission: false, permissionMode: null, grid: null, codexHome: null }))
    const req = { type: 'store.inspect', requestId: randomUUID(), packageId: 'test/robot-fixture' }
    const response = { type: 'store.inspect_result', requestId: req.requestId, ...await f.store.request('lamp', req) }
    expect(DeviceStoreResultSchema.parse(response)).toMatchObject({ package: { installed: true, catalog: false, readiness: { state: 'passed' } }, candidates: [{ agentId: 'fixture-agent', runtime: 'ready' }] })
  })
  it('reports a real doctor failure without spawning', async () => {
    const f = await setup(); rmSync(join(f.source, 'dependency'))
    const reply = await f.store.request('lamp', f.request), id = (reply.operation as { operationId: string }).operationId
    await vi.waitFor(() => expect(f.store.get('lamp', id)).toMatchObject({ state: 'needs_user_action', error: { code: 'DEPENDENCY_NOT_READY' } }))
    expect(f.create).not.toHaveBeenCalled()
  })
  it('canonicalizes symlinks and refuses a workspace held by another session', async () => {
    const f = await setup(), link = join(root, 'alias'); symlinkSync(f.cwd, link)
    state.agents.push({ agentId: 'other', cwd: f.cwd, dsh: null, engine: 'codex', active: true } as RegisteredSession)
    const reply = await f.store.request('lamp', { ...f.request, workspace: { kind: 'existing', path: link } })
    const id = (reply.operation as { operationId: string }).operationId
    await vi.waitFor(() => expect(f.store.get('lamp', id)).toMatchObject({ error: { code: 'WORKSPACE_IN_USE' } }))
    expect(f.create).not.toHaveBeenCalled()
  })
  it('checks official source identity and all uninstalled viewer dependencies', async () => {
    const entry: DshRegistryEntry = { id: 'autonomous/blender', name: 'Blender', engine: 'claude', verified: true, repo: HARNESS_MONOREPO,
      path: 'store/agents/blender', viewerUse: 'autonomous/model-viewer' }
    state.catalog = [entry]
    expect(await deviceStorePackages()).toMatchObject([{ installAllowed: false }])
    state.catalog.push({ id: 'autonomous/model-viewer', name: '3D viewer', kind: 'viewer', verified: true, repo: HARNESS_MONOREPO, path: 'store/viewers/model-viewer' })
    expect(await deviceStorePackages()).toMatchObject([{ installAllowed: true }])
    state.catalog[1].repo = 'https://github.com/someone/else'
    expect(await deviceStorePackages()).toMatchObject([{ installAllowed: false }])
  })
})