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.

11.0 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { fileURLToPath } from 'node:url'
import type { InstalledDsh } from './installed.js'
import { parseDshManifest, readDshManifest } from './manifest.js'
import { materializeWorkspace, resolveDshCommand, skillDirsIn } from './materialize.js'

const STARTER = realpathSync(fileURLToPath(new URL('../../../store/starter', import.meta.url)))

function starter(engine: 'claude' | 'codex' = 'claude'): InstalledDsh {
  const manifest = readDshManifest(STARTER)
  if (!manifest.ok) throw new Error(manifest.error)
  return {
    id: manifest.manifest.id,
    dir: STARTER,
    realDir: STARTER,
    source: STARTER,
    ref: null,
    commit: null,
    linked: true,
    installedAt: 0,
    manifest: { ...manifest.manifest, engine },
  }
}

describe('materializeWorkspace', () => {
  let workspace: string
  beforeEach(() => { workspace = mkdtempSync(join(tmpdir(), 'dsh-ws-')) })
  afterEach(() => rmSync(workspace, { recursive: true, force: true }))

  it('prepares the workspace independently of the engine without publishing instructions or native skills', async () => {
    const result = await materializeWorkspace(starter(), workspace, {}, 'codex')
    expect(result.warnings).toEqual([])
    expect(readFileSync(join(workspace, 'NOTES.md'), 'utf8')).toContain('# Notes')
    expect(readFileSync(join(workspace, '.harness-initialized'), 'utf8')).toBe('initialized by autonomous/starter\n')
    expect(existsSync(join(workspace, 'AGENTS.md'))).toBe(false)
    expect(existsSync(join(workspace, '.claude'))).toBe(false)
    expect(existsSync(join(workspace, '.agents'))).toBe(false)
    expect(existsSync(join(workspace, '.harness'))).toBe(true)
  })

  it('refuses a terminal before copying the template or running init', async () => {
    await expect(materializeWorkspace(starter(), workspace, {}, 'terminal')).rejects.toThrow('does not support terminal')
    expect(readdirSync(workspace)).toEqual([])
  })

  it('runs the init only once: a marked workspace is not re-initialized', async () => {
    await materializeWorkspace(starter(), workspace)
    rmSync(join(workspace, '.harness-initialized'))
    await materializeWorkspace(starter(), workspace)
    expect(existsSync(join(workspace, '.harness-initialized'))).toBe(false)
  })

  it('is idempotent and preserves all project instructions and native skills', async () => {
    writeFileSync(join(workspace, 'AGENTS.md'), '# Repo rules\n')
    writeFileSync(join(workspace, 'CLAUDE.md'), '# Claude rules\n')
    mkdirSync(join(workspace, '.claude/skills/hello'), { recursive: true })
    await materializeWorkspace(starter(), workspace)
    const again = await materializeWorkspace(starter(), workspace)
    expect(again.created).toEqual([])
    expect(again.kept).toEqual(['NOTES.md'])
    expect(readFileSync(join(workspace, 'AGENTS.md'), 'utf8')).toBe('# Repo rules\n')
    expect(readFileSync(join(workspace, 'CLAUDE.md'), 'utf8')).toBe('# Claude rules\n')
    expect(lstatSync(join(workspace, '.claude/skills/hello')).isDirectory()).toBe(true)
  })
})

describe('skillDirsIn', () => {
  it('lists SKILL.md-bearing subdirectories, or the directory itself when it is one skill', () => {
    expect(skillDirsIn(join(STARTER, 'skills'))).toEqual([join(STARTER, 'skills', 'hello')])
    expect(skillDirsIn(join(STARTER, 'skills', 'hello'))).toEqual([join(STARTER, 'skills', 'hello')])
    expect(skillDirsIn(join(STARTER, 'template'))).toEqual([])
    expect(skillDirsIn('/nonexistent')).toEqual([])
  })
})

describe('resolveDshCommand', () => {
  it('turns a path inside the harness into a quoted absolute path and leaves shell lines alone', () => {
    expect(resolveDshCommand({ realDir: STARTER }, 'toolchain/init-workspace.sh')).toBe(`'${join(STARTER, 'toolchain', 'init-workspace.sh')}'`)
    expect(resolveDshCommand({ realDir: STARTER }, 'toolchain/missing.sh')).toBe('toolchain/missing.sh')
    expect(resolveDshCommand({ realDir: STARTER }, 'npm run viewer -- --port $HARNESS_VIEWER_PORT')).toBe('npm run viewer -- --port $HARNESS_VIEWER_PORT')
  })

  it('quotes an install path with a quote in it so the shell runs the script it names', async () => {
    const dir = realpathSync(mkdtempSync(join(tmpdir(), "dsh-it's-")))
    try {
      writeFileSync(join(dir, 'run.sh'), '#!/bin/sh\necho "ran $1"\n', { mode: 0o755 })
      const command = resolveDshCommand({ realDir: dir }, 'run.sh')
      expect(command).toBe(`'${join(dir, 'run.sh').replace(/'/g, `'\\''`)}'`)
      const { execFileSync } = await import('node:child_process')
      expect(execFileSync('/bin/sh', ['-c', `${command} ok`], { encoding: 'utf8' })).toBe('ran ok\n')
    } finally {
      rmSync(dir, { recursive: true, force: true })
    }
  })
})

describe('materializeWorkspace, on harnesses other than the starter', () => {
  let root: string
  let harness: string
  let workspace: string
  beforeEach(() => {
    root = realpathSync(mkdtempSync(join(tmpdir(), 'dsh-mat-')))
    harness = join(root, 'harness')
    workspace = join(root, 'workspace')
    mkdirSync(harness)
    mkdirSync(workspace)
  })
  afterEach(() => {
    vi.useRealTimers()
    rmSync(root, { recursive: true, force: true })
  })

  const install = (manifest: Record<string, unknown>, files: Record<string, string> = {}): InstalledDsh => {
    for (const [name, body] of Object.entries(files)) {
      mkdirSync(join(harness, name, '..'), { recursive: true })
      writeFileSync(join(harness, name), body, { mode: name.endsWith('.sh') ? 0o755 : 0o644 })
    }
    const read = parseDshManifest(JSON.stringify({ spec: 1, id: 'acme/thing', name: 'Thing', ...manifest }))
    if (!read.ok) throw new Error(read.error)
    return { id: 'acme/thing', dir: harness, realDir: harness, source: harness, ref: null, commit: null, linked: true, installedAt: 0, manifest: read.manifest }
  }

  it('lays nothing out for a viewer package', async () => {
    const dsh = install({ kind: 'viewer', viewer: { command: 'v.sh', url: 'http://127.0.0.1:${port}/' } })
    const result = await materializeWorkspace(dsh, workspace)
    expect(result).toEqual({ created: [], kept: [], warnings: ['acme/thing is a viewer package; it has no workspace to lay out'], initLines: [] })
    expect(readdirSync(workspace)).toEqual([])
  })

  it('a harness with no workspace, instructions or skills gets only .harness/', async () => {
    const result = await materializeWorkspace(install({ engine: 'codex' }), workspace)
    expect(result).toEqual({ created: [], kept: [], warnings: [], initLines: [] })
    expect(readdirSync(workspace)).toEqual(['.harness'])
  })

  it('with no marker declared, copies the template (never over a file) and runs the init at every create', async () => {
    const dsh = install({ engine: 'codex', workspace: { template: 'template', init: 'init.sh' } }, {
      'template/deck.md': '# from the template\n',
      'init.sh': '#!/bin/sh\necho "init in $(basename "$PWD") for $HARNESS_DSH" >> init.log\necho ran\n',
    })
    writeFileSync(join(workspace, 'deck.md'), '# mine\n')
    const first = await materializeWorkspace(dsh, workspace)
    expect(first.created).toContain(`template → ${workspace}`)
    expect(first.initLines).toEqual(['ran'])
    expect(readFileSync(join(workspace, 'deck.md'), 'utf8')).toBe('# mine\n')
    await materializeWorkspace(dsh, workspace)
    expect(readFileSync(join(workspace, 'init.log'), 'utf8')).toBe('init in workspace for acme/thing\ninit in workspace for acme/thing\n')
  })

  it('reports a missing template; runtime binding validates instructions and skills separately', async () => {
    const dsh = install({ engine: 'claude', workspace: { template: 'gone', marker: 'deck.md' }, agent: { instructions: 'MISSING.md', skills: ['empty'] } }, { 'empty/README.md': '' })
    const result = await materializeWorkspace(dsh, workspace)
    expect(result.warnings).toEqual([
      `template ${join(harness, 'gone')} is missing`,
    ])
    expect(existsSync(join(workspace, 'AGENTS.md'))).toBe(false)
    expect(existsSync(join(workspace, 'CLAUDE.md'))).toBe(false)
  })

  it('an init that fails, or is killed, is a warning with how it ended, never a thrown error', async () => {
    const failing = install({ engine: 'codex', workspace: { marker: 'done', init: 'echo half-way; exit 3' } })
    const failed = await materializeWorkspace(failing, workspace)
    expect(failed.initLines).toEqual(['half-way'])
    expect(failed.warnings).toEqual(['init exited 3'])
    const killed = install({ engine: 'codex', workspace: { marker: 'done', init: 'kill -KILL $$' } })
    expect((await materializeWorkspace(killed, workspace)).warnings).toEqual(['init exited SIGKILL'])
  })

  it('on Windows without Git Bash, says the workspace init could not start, not that a setup or check script needs it', async () => {
    const platform = Object.getOwnPropertyDescriptor(process, 'platform')!
    // A Mac or Linux PATH has no git.exe, and the Windows install folders are unset here: no Git Bash is found.
    Object.defineProperty(process, 'platform', { ...platform, value: 'win32' })
    try {
      const result = await materializeWorkspace(install({ engine: 'codex', workspace: { marker: 'done', init: 'echo hi' } }), workspace)
      expect(result.initLines).toEqual(["could not start: This harness's workspace init needs Git Bash on Windows, and it was not found. Install Git for Windows from https://git-scm.com/download/win (or run: winget install --id Git.Git -e), then try again."])
      expect(result.warnings).toEqual(['init exited 127'])
    } finally {
      Object.defineProperty(process, 'platform', platform)
    }
  })

  it('an init that is still running after five minutes is stopped and said to have timed out', async () => {
    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
    const slow = install({ engine: 'codex', workspace: { marker: 'done', init: 'sleep 30' } })
    const pending = materializeWorkspace(slow, workspace)
    // And the SIGKILL grace after it: an interactive bash, the usual shell on Linux, ignores SIGTERM.
    vi.advanceTimersByTime(5 * 60_000 + 3_000)
    const result = await pending
    expect(result.warnings).toEqual(['init exited by timeout'])
  })

  it('skips skill entries that cannot be statted', () => {
    const dsh = install({ engine: 'codex', agent: { skills: ['skills'] } }, { 'skills/draw/SKILL.md': '# Draw' })
    symlinkSync(join(root, 'nowhere'), join(harness, 'skills', 'dangling'))
    expect(skillDirsIn(join(dsh.realDir, 'skills'))).toEqual([join(harness, 'skills/draw')])
  })

  it('refuses an agent manifest with no engine before writing workspace files', async () => {
    const dsh = install({ engine: 'claude', agent: { instructions: 'AGENTS.md', skills: ['skills'] } }, { 'AGENTS.md': '# Thing\n', 'skills/draw/SKILL.md': '' })
    const { engine: _engine, ...manifest } = dsh.manifest
    await expect(materializeWorkspace({ ...dsh, manifest }, workspace)).rejects.toThrow('does not support')
    expect(readdirSync(workspace)).toEqual([])
  })
})