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.

19.4 KB
Raw Blame
import { prepareHarnessLaunch } from './runtime.js'
import { updateDsh } from './update.js'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { execFileSync } from 'node:child_process'
import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join, relative } from 'node:path'
import { env } from '../config/env.js'
import { dshInstallDir, installedDsh, invalidateInstalledDsh, readInstalledIndex, upsertInstalledRecord } from './installed.js'
import { installDsh, removeDsh, type DshInstallProgress } from './install.js'
import { materializeWorkspace } from './materialize.js'
import { dshUpdateInfo, samePackageSource } from './updates.js'
import { type DshRegistryEntry } from './registry.js'
import { dshListRows } from './wire.js'

const faults = vi.hoisted(() => ({ cleanup: false, place: false }))
vi.mock('node:fs', async original => {
  const fs = await original<typeof import('node:fs')>()
  return { ...fs,
    renameSync: (...args: Parameters<typeof fs.renameSync>) => {
      if (faults.place && String(args[0]).includes('/.tmp-') && String(args[1]).endsWith('/acme/thing')) throw new Error('disk full while placing update')
      return fs.renameSync(...args)
    },
    rmSync: (...args: Parameters<typeof fs.rmSync>) => {
      if (faults.cleanup && String(args[0]).includes('/.previous-')) throw new Error('backup is busy')
      return fs.rmSync(...args)
    },
  }
})

describe('package updates', { timeout: 30_000 }, () => {
  let root: string
  let savedRoot: string
  const id = 'acme/thing'
  const manifest = { spec: 1, id, name: 'Thing', engine: 'claude',
    agent: { instructions: 'AGENTS.md', skills: ['skills'] },
    workspace: { template: 'template', marker: 'project.txt' },
    toolchain: { setup: './setup.sh', doctor: './doctor.sh' } }
  const git = (repo: string, ...args: string[]): string => execFileSync('git', ['-C', repo, ...args], {
    encoding: 'utf8', env: { ...process.env, GIT_AUTHOR_NAME: 'test', GIT_AUTHOR_EMAIL: '[email protected]', GIT_COMMITTER_NAME: 'test', GIT_COMMITTER_EMAIL: '[email protected]' },
  }).trim()
  const write = (dir: string, files: Record<string, string>): void => {
    for (const [name, body] of Object.entries(files)) {
      mkdirSync(join(dir, name, '..'), { recursive: true })
      writeFileSync(join(dir, name), body, { mode: name.endsWith('.sh') ? 0o755 : 0o644 })
    }
  }
  const commit = (repo: string): string => { git(repo, 'add', '-A'); git(repo, 'commit', '-qm', 'package version'); return git(repo, 'rev-parse', 'HEAD') }
  const create = (path?: string): string => {
    const repo = join(root, 'repo')
    const dir = path ? join(repo, path) : repo
    write(dir, {
      'harness.json': JSON.stringify(manifest), 'AGENTS.md': '# Original instructions\n',
      'skills/task/SKILL.md': '# Original skill\n', 'template/project.txt': 'template\n',
      'setup.sh': '#!/bin/sh\npwd > setup-path\n', 'doctor.sh': '#!/bin/sh\ntest -f setup-path\n',
    })
    git(repo, 'init', '-q', '-b', 'main'); commit(repo)
    return repo
  }
  const catalog = (repo: string, ref: string, path?: string): DshRegistryEntry => ({
    id, name: 'Thing', engine: 'claude', repo, ref, path,
    revision: git(repo, 'rev-parse', path ? `${ref}:${path}` : `${ref}^{tree}`),
  })
  const update = (entry?: DshRegistryEntry, progress?: DshInstallProgress[]) => updateDsh({ id,
    registry: candidate => candidate === id ? entry : undefined, onProgress: p => progress?.push(p) })
  beforeEach(() => {
    root = realpathSync(mkdtempSync(join(tmpdir(), 'dsh-update-')))
    const shell = join(root, 'test-shell')
    writeFileSync(shell, '#!/bin/sh\nexec /bin/sh -c "$2"\n', { mode: 0o755 })
    vi.stubEnv('SHELL', shell)
    savedRoot = env.DSH_DIR
    env.DSH_DIR = join(root, 'installed')
    invalidateInstalledDsh()
  })
  afterEach(() => {
    faults.cleanup = false
    faults.place = false
    vi.unstubAllEnvs()
    env.DSH_DIR = savedRoot
    invalidateInstalledDsh()
    rmSync(root, { recursive: true, force: true })
  })

  it('refreshes the default catalog and treats the same recorded commit as a no-op for legacy installs', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const [record] = readInstalledIndex()
    delete record.revision
    upsertInstalledRecord(record)
    const lines: string[] = []
    expect((await updateDsh({ id, onLine: line => lines.push(line) })).ok).toBe(true)
    expect(lines).toContain(`${id} is already up to date`)
  })

  it('keeps release-bundled core packages on the Harness update path without fetching a Store copy', async () => {
    upsertInstalledRecord({ id, dir: join(root, 'bundled'), source: 'builtin:harness-monitor',
      ref: null, commit: null, linked: false, installedAt: 123 })
    const before = readInstalledIndex()
    const registry = vi.fn()
    const result = await updateDsh({ id, registry })
    expect(result).toEqual({ ok: false, error: 'BUNDLED_PACKAGE',
      detail: `${id} updates automatically with Harness. Update Harness to receive the latest core packages.` })
    expect(registry).not.toHaveBeenCalled()
    expect(readInstalledIndex()).toEqual(before)
  })

  it('repairs a missing installed directory and a record with unknown commit/ref', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const [record] = readInstalledIndex()
    upsertInstalledRecord({ ...record, commit: null, revision: null })
    rmSync(record.dir, { recursive: true })
    expect((await update()).ok).toBe(true)
    expect(installedDsh(id)?.commit).toBe(git(repo, 'rev-parse', 'HEAD'))
  })

  it('rejects a kind change, but updates viewer packages independently', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const viewer = { spec: 1, id, kind: 'viewer', name: 'Viewer', viewer: { command: './viewer.sh', url: 'http://127.0.0.1:${port}/' } }
    write(repo, { 'harness.json': JSON.stringify(viewer) })
    expect(await update(catalog(repo, commit(repo)))).toMatchObject({ ok: false, error: 'PACKAGE_KIND_MISMATCH' })
    removeDsh(id)
    await installDsh({ source: repo })
    write(repo, { 'harness.json': JSON.stringify({ ...viewer, name: 'Updated viewer' }) })
    expect((await update(catalog(repo, commit(repo)))).ok).toBe(true)
    expect(installedDsh(id)?.manifest.name).toBe('Updated viewer')
  })

  it('refuses a symlink even if its installed record incorrectly calls it a clone', async () => {
    const repo = create()
    await installDsh({ source: repo, link: true })
    const [record] = readInstalledIndex()
    upsertInstalledRecord({ ...record, linked: false })
    write(repo, { 'AGENTS.md': '# Changed checkout' })
    expect(await update(catalog(repo, commit(repo)))).toMatchObject({ ok: false, error: 'LINKED_INSTALL' })
    expect(lstatSync(record.dir).isSymbolicLink()).toBe(true)
  })

  it('restores the old package if moving the new files fails and retains a busy backup after success', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const before = readInstalledIndex()
    write(repo, { 'AGENTS.md': '# Updated' })
    const entry = catalog(repo, commit(repo))
    faults.place = true
    expect(await update(entry)).toMatchObject({ ok: false, error: 'UPDATE_FAILED', detail: 'disk full while placing update' })
    expect(readInstalledIndex()).toEqual(before)
    expect(readFileSync(join(dshInstallDir(id), 'AGENTS.md'), 'utf8')).toBe('# Original instructions\n')
    faults.place = false
    faults.cleanup = true
    const lines: string[] = []
    expect((await updateDsh({ id, registry: () => entry, onLine: line => lines.push(line) })).ok).toBe(true)
    expect(lines.some(line => line.startsWith('Previous package retained at'))).toBe(true)
    expect(installedDsh(id)?.commit).toBe(entry.ref)
  })

  it('reports non-Error failures and releases its lock', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const result = await updateDsh({ id, registry: () => { throw 'connection closed' } })
    expect(result).toMatchObject({ ok: false, error: 'UPDATE_FAILED', detail: 'connection closed' })
    expect((await update()).ok).toBe(true)
  })

  for (const path of [undefined, 'store/agents/thing']) {
    it(`updates ${path ?? 'a whole repo'} at the catalog commit, preserving workspace files and skill links`, async () => {
      const repo = create(path)
      expect((await installDsh({ source: repo, ref: 'main', path })).ok).toBe(true)
      const before = installedDsh(id)!
      const workspace = join(root, 'workspace')
      mkdirSync(workspace)
      await materializeWorkspace(before, workspace)
      const launch = prepareHarnessLaunch(before, workspace, 'claude', 'session')
      write(workspace, { 'project.txt': 'my finished work\n', 'AGENTS.md': 'my custom instructions\n', '.harness/verdict.json': '{"ready":true}', 'notes.md': 'my notes' })
      const skill = join(launch.env.HARNESS_SKILLS_DIR!, 'task')
      const link = readlinkSync(skill)
      const dir = path ? join(repo, path) : repo
      write(dir, { 'skills/task/SKILL.md': '# Updated skill\n', 'AGENTS.md': '# New instructions\n', 'template/project.txt': 'new template\n' })
      const ref = commit(repo)
      const entry = catalog(repo, ref, path)
      expect(dshListRows([before], [entry])[0]).toMatchObject({ installedCommit: before.commit, availableCommit: ref, updateAvailable: true })
      write(dir, { 'skills/task/SKILL.md': '# Unpublished skill\n' }); commit(repo)
      const phases: DshInstallProgress[] = []
      const result = await update(entry, phases)
      expect(result.ok, JSON.stringify(result)).toBe(true)
      const after = installedDsh(id)!
      expect(after).toMatchObject({ commit: ref, revision: entry.revision, dir: before.dir, installedAt: before.installedAt, updatedAt: expect.any(Number) })
      expect(readFileSync(join(after.dir, 'setup-path'), 'utf8').trim()).toBe(after.dir)
      expect(readFileSync(join(workspace, 'project.txt'), 'utf8')).toBe('my finished work\n')
      expect(readFileSync(join(workspace, 'AGENTS.md'), 'utf8')).toBe('my custom instructions\n')
      expect(readFileSync(join(workspace, '.harness/verdict.json'), 'utf8')).toBe('{"ready":true}')
      expect(readFileSync(join(workspace, 'notes.md'), 'utf8')).toBe('my notes')
      expect(readlinkSync(skill)).toBe(link)
      expect(readFileSync(join(skill, 'SKILL.md'), 'utf8')).toBe('# Updated skill\n')
      expect(dshUpdateInfo(after, entry).updateAvailable).toBe(false)
      expect(phases.map(p => p.phase)).toEqual(['clone', 'setup', 'doctor', 'done'])
      expect(readdirSync(env.DSH_DIR).filter(name => name.startsWith('.'))).toEqual([])
    })
  }

  for (const failure of ['setup', 'doctor']) {
    it(`restores the complete old package and index when ${failure} fails, then supports retry`, async () => {
      const repo = create()
      await installDsh({ source: repo, ref: 'main' })
      const before = readInstalledIndex()
      write(dshInstallDir(id), { 'local-cache': 'keep me' })
      write(repo, { [`${failure}.sh`]: '#!/bin/sh\necho "miss broken update"\nexit 1\n', 'AGENTS.md': '# Bad version' })
      const entry = catalog(repo, commit(repo))
      expect(await update(entry)).toMatchObject({ ok: false, error: `${failure.toUpperCase()}_FAILED` })
      expect(readInstalledIndex()).toEqual(before)
      expect(readFileSync(join(dshInstallDir(id), 'AGENTS.md'), 'utf8')).toBe('# Original instructions\n')
      expect(readFileSync(join(dshInstallDir(id), 'local-cache'), 'utf8')).toBe('keep me')
      write(repo, { [`${failure}.sh`]: '#!/bin/sh\npwd > setup-path\necho "ok fixed"\n' })
      expect((await update(catalog(repo, commit(repo)))).ok).toBe(true)
    })
  }

  it('uses the recorded source/ref for an unlisted install and does not redirect a fork with the same id', async () => {
    const repo = create()
    await installDsh({ source: repo, ref: 'main' })
    write(repo, { 'AGENTS.md': '# New version\n' })
    const ref = commit(repo)
    const unrelated = { ...catalog(repo, ref), repo: join(root, 'different-source') }
    expect(dshUpdateInfo(installedDsh(id)!, unrelated).updateAvailable).toBe(false)
    expect((await update(unrelated)).ok).toBe(true)
    expect(installedDsh(id)?.commit).toBe(ref)
  })

  it('offers the official repository rename as an update without treating other sources or folders as aliases', async () => {
    const repo = create('store/agents/thing')
    await installDsh({ source: repo, path: 'store/agents/thing' })
    const record = { ...installedDsh(id)!, source: 'https://github.com/autonomous-ai/autonomous-harness.git/', revision: 'a'.repeat(40) }
    const entry = { ...catalog(repo, record.commit!, record.path ?? undefined), repo: 'https://github.com/autonomous-ai/openharness', ref: 'b'.repeat(40), revision: 'c'.repeat(40) }
    expect(dshUpdateInfo(record, entry)).toMatchObject({ updateAvailable: true, availableCommit: entry.ref })
    expect(samePackageSource({ ...record, source: entry.repo }, { ...entry, repo: record.source })).toBe(true)
    for (const source of [
      'https://github.com/someone/autonomous-harness',
      'https://github.com/someone/openharness',
      'https://example.test/autonomous-ai/autonomous-harness',
      'https://github.com/autonomous-ai/autonomous-harness-extra',
    ]) expect(dshUpdateInfo({ ...record, source }, entry).updateAvailable).toBe(false)
    expect(dshUpdateInfo(record, { ...entry, path: 'store/agents/other' }).updateAvailable).toBe(false)
    expect(dshUpdateInfo({ ...record, linked: true }, entry).updateAvailable).toBe(false)
  })

  it('updates a legacy official install from the canonical catalog source and preserves its workspace', async () => {
    const path = 'store/agents/thing'
    const repo = create(path)
    await installDsh({ source: repo, path, ref: 'main' })
    const before = installedDsh(id)!
    const workspace = join(root, 'my-project')
    mkdirSync(workspace)
    await materializeWorkspace(before, workspace)
    write(workspace, { 'project.txt': 'my authored work\n' })
    const legacy = 'https://github.com/autonomous-ai/autonomous-harness'
    const canonical = 'https://github.com/autonomous-ai/openharness'
    upsertInstalledRecord({ ...before, source: legacy, ref: 'viewer-packages' })
    write(join(repo, path), { 'AGENTS.md': '# Current featured experience\n' })
    const entry = { ...catalog(repo, commit(repo), path), repo: canonical }
    // Exercise real clone/setup/doctor without the network. Using the legacy URL would fail.
    vi.stubEnv('GIT_CONFIG_COUNT', '2')
    vi.stubEnv('GIT_CONFIG_KEY_0', `url.${repo}.insteadOf`)
    vi.stubEnv('GIT_CONFIG_VALUE_0', canonical)
    vi.stubEnv('GIT_CONFIG_KEY_1', `url.${join(root, 'retired-repo')}.insteadOf`)
    vi.stubEnv('GIT_CONFIG_VALUE_1', legacy)
    const result = await update(entry)
    expect(result.ok, JSON.stringify(result)).toBe(true)
    expect(installedDsh(id)).toMatchObject({ source: canonical, ref: entry.ref, commit: entry.ref, revision: entry.revision })
    expect(readFileSync(join(before.dir, 'AGENTS.md'), 'utf8')).toBe('# Current featured experience\n')
    expect(readFileSync(join(workspace, 'project.txt'), 'utf8')).toBe('my authored work\n')
    expect(dshUpdateInfo(installedDsh(id)!, entry).updateAvailable).toBe(false)
  })

  it('records local clone sources absolutely so updates do not depend on the original working directory', async () => {
    const repo = create()
    await installDsh({ source: relative(process.cwd(), repo) })
    expect(readInstalledIndex()[0]!.source).toBe(repo)
    write(repo, { 'AGENTS.md': '# Latest' })
    const ref = commit(repo)
    expect((await update()).ok).toBe(true)
    expect(installedDsh(id)?.commit).toBe(ref)
  })

  it('restores the harness if its update introduces a viewer that cannot be installed', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const before = readInstalledIndex()
    write(repo, { 'harness.json': JSON.stringify({ ...manifest, viewer: { use: 'acme/unpublished' } }) })
    expect(await update(catalog(repo, commit(repo)))).toMatchObject({ ok: false, error: 'VIEWER_UNAVAILABLE' })
    expect(readInstalledIndex()).toEqual(before)
    expect(installedDsh(id)?.manifest.viewer).toBeUndefined()
  })

  it('skips unchanged package content even when another folder changed in the monorepo', async () => {
    const path = 'store/agents/thing'
    const repo = create(path)
    await installDsh({ source: repo, path, ref: 'main' })
    const before = readInstalledIndex()
    write(repo, { 'unrelated.txt': 'new app version' })
    const entry = catalog(repo, commit(repo), path)
    expect(dshUpdateInfo(installedDsh(id)!, entry).updateAvailable).toBe(false)
    const phases: DshInstallProgress[] = []
    expect((await update(entry, phases)).ok).toBe(true)
    expect(phases.map(p => p.phase)).toEqual(['clone', 'done'])
    expect(readInstalledIndex()).toEqual(before)
  })

  it('handles older records with no revision and refuses to change a linked checkout', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const [record] = readInstalledIndex()
    delete record.revision
    upsertInstalledRecord(record)
    write(repo, { 'AGENTS.md': '# Updated' })
    const entry = catalog(repo, commit(repo))
    expect(dshUpdateInfo(record, entry).updateAvailable).toBe(true)
    expect((await update(entry)).ok).toBe(true)
    expect(installedDsh(id)?.revision).toBe(entry.revision)
    await installDsh({ source: repo, link: true })
    expect(dshUpdateInfo(installedDsh(id)!, entry).updateAvailable).toBe(false)
    expect(await update(entry)).toMatchObject({ ok: false, error: 'LINKED_INSTALL' })
    expect(lstatSync(dshInstallDir(id)).isSymbolicLink()).toBe(true)
    expect(readFileSync(join(repo, 'AGENTS.md'), 'utf8')).toBe('# Updated')
  })

  it('leaves the installation intact after a clone failure or wrong package identity', async () => {
    expect(await update()).toMatchObject({ ok: false, error: 'NOT_INSTALLED' })
    const repo = create()
    await installDsh({ source: repo })
    const before = readInstalledIndex()
    expect(await update({ ...catalog(repo, git(repo, 'rev-parse', 'HEAD')), ref: 'no-such-ref' })).toMatchObject({ ok: false, error: 'CLONE_FAILED' })
    write(repo, { 'harness.json': JSON.stringify({ ...manifest, id: 'acme/other' }) })
    expect(await update(catalog(repo, commit(repo)))).toMatchObject({ ok: false, error: 'PACKAGE_ID_MISMATCH' })
    expect(readInstalledIndex()).toEqual(before)
    expect(installedDsh(id)?.manifest.id).toBe(id)
  })

  it('blocks concurrent updates, installs and removal until the update finishes', async () => {
    const repo = create()
    await installDsh({ source: repo })
    const gate = join(root, 'release')
    write(repo, { 'setup.sh': `#!/bin/sh\necho waiting\nwhile [ ! -f '${gate}' ]; do sleep 0.05; done\npwd > setup-path\n` })
    const entry = catalog(repo, commit(repo))
    let waiting = false
    const pending = updateDsh({ id, registry: () => entry, onLine: line => { if (line === 'waiting') waiting = true } })
    try {
      await vi.waitFor(() => expect(waiting).toBe(true), { timeout: 5000 })
      expect(removeDsh(id)).toMatchObject({ ok: false, error: 'DSH_BUSY' })
      expect(await update(entry)).toMatchObject({ ok: false, error: 'DSH_BUSY' })
      expect(await installDsh({ source: repo })).toMatchObject({ ok: false, error: 'DSH_BUSY' })
    } finally { writeFileSync(gate, '') }
    expect((await pending).ok).toBe(true)
    expect(existsSync(join(dshInstallDir(id), 'harness.json'))).toBe(true)
  })
})