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.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
// node --test test/ — the pane's server, run as Harness runs it: a child process on a free loopback port over a
// temp workspace. RDKit is never needed: the Python worker is a fake that speaks the same one-JSON-line
// protocol as `harness_rdkit.py serve`. The worker's 60 s timeout and the SSE ping's 20 s interval are
// shortened by a preload that rewrites exactly those two delays, so their branches run in milliseconds.
import assert from 'node:assert/strict'
import { spawn } from 'node:child_process'
import { createHash } from 'node:crypto'
import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, utimesSync, writeFileSync } from 'node:fs'
import { request } from 'node:http'
import { connect, createServer } from 'node:net'
import { tmpdir } from 'node:os'
import { dirname, join } from 'node:path'
import { after, before, describe, test } from 'node:test'
import { fileURLToPath } from 'node:url'
import { workspaceFileUrl } from '../pane/files.mjs'
const PKG = join(dirname(fileURLToPath(import.meta.url)), '..')
const VIEWER = join(PKG, 'viewer.mjs')
const BUNDLE = join(PKG, 'node_modules/3dmol/build/3Dmol-min.js')
const scratch = mkdtempSync(join(tmpdir(), 'rdkit-viewer-test-'))
after(() => rmSync(scratch, { recursive: true, force: true }))
const PRELOAD = join(scratch, 'short-timers.mjs')
writeFileSync(PRELOAD, `
const setTimeoutReal = globalThis.setTimeout, setIntervalReal = globalThis.setInterval
globalThis.setTimeout = (fn, ms, ...rest) => setTimeoutReal(fn, ms === 60_000 ? Number(process.env.TEST_ASK_TIMEOUT_MS) : ms, ...rest)
globalThis.setInterval = (fn, ms, ...rest) => setIntervalReal(fn, ms === 20_000 ? Number(process.env.TEST_PING_MS) : ms, ...rest)
`)
// The fake worker: by the requested file's name it answers, fails, says nothing, never answers, or dies.
const WORKER_LOG = join(scratch, 'worker.log')
const FAKE_PYTHON = join(scratch, 'python')
writeFileSync(FAKE_PYTHON, `#!${process.execPath}
const { appendFileSync } = require('node:fs')
const { basename } = require('node:path')
const log = (line) => appendFileSync(${JSON.stringify(WORKER_LOG)}, line + '\\n')
const send = (reply) => process.stdout.write(JSON.stringify(reply) + '\\n')
log('start ' + process.argv.slice(2).join(' '))
let buffer = ''
process.stdin.on('data', (chunk) => {
buffer += chunk
let at
while ((at = buffer.indexOf('\\n')) >= 0) {
const request = JSON.parse(buffer.slice(0, at)); buffer = buffer.slice(at + 1)
const name = basename(request.path)
log('ask ' + name)
if (name.startsWith('slow')) continue
if (name.startsWith('crash')) process.exit(3)
if (name.startsWith('fail')) { send({ id: request.id, ok: false, error: 'ValueError: no molecule' }); continue }
if (name.startsWith('blank')) { send({ id: request.id, ok: false }); continue }
process.stdout.write('not json\\n')
send({ id: 99999, ok: true, result: 'nobody asked' })
process.stderr.write(' \\n')
setTimeout(() => process.stderr.write('warming up\\n'), 30)
const text = JSON.stringify({ id: request.id, ok: true, result: { name, computedBy: 'viewer', op: request.op, argv: process.argv.slice(2), pythonpath: process.env.PYTHONPATH } }) + '\\n'
process.stdout.write(text.slice(0, 12))
setTimeout(() => process.stdout.write(text.slice(12)), 10)
}
})
`)
chmodSync(FAKE_PYTHON, 0o755)
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
const sha1 = (text) => createHash('sha1').update(text).digest('hex')
const freePort = () => new Promise((resolve) => {
const probe = createServer()
probe.listen(0, '127.0.0.1', () => { const { port } = probe.address(); probe.close(() => resolve(port)) })
})
function put(root, rel, text = '', ageSeconds = 0) {
const full = join(root, rel)
mkdirSync(dirname(full), { recursive: true })
writeFileSync(full, text)
if (ageSeconds) { const t = Date.now() / 1000 - ageSeconds; utimesSync(full, t, t) }
return full
}
// The viewer as Harness runs it. `env` is merged over a clean environment (no HARNESS_ or RDKIT_ variables leak in).
async function viewer({ env = {}, workspace } = {}) {
const ws = workspace ?? mkdtempSync(join(scratch, 'ws-'))
const port = await freePort()
const clean = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^(HARNESS_|RDKIT_)/.test(k)))
const child = spawn(process.execPath, ['--import', PRELOAD, VIEWER], {
env: { ...clean, HARNESS_VIEWER_PORT: String(port), HARNESS_WORKSPACE: ws, TEST_ASK_TIMEOUT_MS: '10000', TEST_PING_MS: '60000', ...env },
stdio: ['ignore', 'pipe', 'pipe'],
})
let output = ''
child.stdout.on('data', (chunk) => { output += chunk })
child.stderr.on('data', (chunk) => { output += chunk })
const exited = new Promise((resolve) => child.on('exit', (code, signal) => resolve({ code, signal })))
for (let i = 0; !output.includes('listening on') && child.exitCode === null && i < 200; i++) await sleep(20)
assert.match(output, /\[rdkit\] listening on http:\/\/127\.0\.0\.1:\d+\//)
return {
ws, port, child, exited,
output: () => output,
get: (path, options) => http(port, path, options),
json: async (path) => { const r = await http(port, path); return { ...r, body: JSON.parse(r.body) } },
stop: async (signal = 'SIGTERM') => { if (child.exitCode === null) child.kill(signal); return exited },
}
}
function http(port, path, { method = 'GET', headers = {}, body } = {}) {
return new Promise((resolve, reject) => {
const req = request({ host: '127.0.0.1', port, path, method, headers }, (res) => {
let body = ''
res.setEncoding('utf8')
res.on('data', (chunk) => { body += chunk })
res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body }))
})
req.on('error', reject)
req.end(body)
})
}
/** An SSE connection that collects events; `until(predicate)` waits for one. */
function events(port) {
const seen = []
let res
const ready = new Promise((resolve) => {
const req = request({ host: '127.0.0.1', port, path: '/events' }, (response) => {
res = response
response.setEncoding('utf8')
response.on('data', (chunk) => { seen.push(chunk); resolve() })
})
req.end()
})
return {
ready,
text: () => seen.join(''),
until: async (predicate, ms = 5000) => {
for (let t = 0; t < ms; t += 20) { if (predicate(seen.join(''))) return seen.join(''); await sleep(20) }
assert.fail(`no matching event in: ${seen.join('')}`)
},
close: () => res?.destroy(),
}
}
describe('files', () => {
let v
before(async () => { v = await viewer() })
after(() => v.stop())
test('the pane, with its types, and HEAD without a body', async () => {
const page = await v.get('/')
assert.equal(page.status, 200)
assert.equal(page.headers['content-type'], 'text/html; charset=utf-8')
assert.equal((await v.get('/app.css')).headers['content-type'], 'text/css; charset=utf-8')
const head = await v.get('/app.js', { method: 'HEAD' })
assert.equal(head.status, 200)
assert.equal(head.body, '')
assert.ok(Number(head.headers['content-length']) > 1000)
assert.equal(head.headers['content-type'], 'text/javascript; charset=utf-8')
assert.equal((await v.get('/files.mjs')).headers['content-type'], 'text/javascript; charset=utf-8')
})
test('3Dmol.js from this package, cached, and nothing else under /vendor/', async () => {
const bundle = await v.get('/vendor/3Dmol-min.js', { method: 'HEAD' })
if (existsSync(BUNDLE)) {
assert.equal(bundle.status, 200)
assert.equal(bundle.headers['cache-control'], 'max-age=3600')
} else {
assert.equal(bundle.status, 404) // a checkout without npm ci
}
assert.equal((await v.get('/vendor/jquery.js')).status, 404)
})
test('bond-scan writes require the pane token, same origin and bounded input', async () => {
const page = await v.get('/')
const token = page.body.match(/name="torsion-token" content="([a-f0-9]{64})"/)[1]
const endpoint = '/api/torsion/keep', method = 'POST'
assert.equal((await v.get(endpoint, { method, body: '{}' })).status, 403)
assert.equal((await v.get(endpoint, { method, headers: { 'x-torsion-token': token, origin: 'https://outside.example' }, body: '{}' })).status, 403)
assert.equal((await v.get(endpoint, { method, headers: { 'x-torsion-token': token, host: 'outside.example' }, body: '{}' })).status, 403)
const headers = { 'x-torsion-token': token, origin: `http://127.0.0.1:${v.port}` }
assert.equal((await v.get(endpoint, { method, headers, body: '{bad json' })).status, 400)
assert.equal((await v.get(endpoint, { method, headers, body: '{}' })).status, 400)
assert.equal((await v.get(endpoint, { method, headers: { ...headers, 'content-length': '262145' }, body: 'x'.repeat(262145) })).status, 413)
assert.equal((await v.get(endpoint, { method, headers: { ...headers, 'transfer-encoding': 'chunked' }, body: 'x'.repeat(262145) })).status, 413)
assert.equal((await v.get('/', { method: 'PUT' })).status, 405)
assert.deepEqual((await v.json('/api/torsions')).body, [])
assert.equal((await v.get('/torsion-pane.mjs')).headers['content-type'], 'text/javascript; charset=utf-8')
assert.equal((await v.get('/')).status, 200)
})
test('workspace files, a download, and nothing outside the workspace', async () => {
put(v.ws, 'out/x.json', '{"a":1}')
put(v.ws, 'out/blob.bin', 'b')
put(v.ws, 'out/a"b.sdf', 'mol')
const json = await v.get('/out/x.json')
assert.equal(json.status, 200)
assert.equal(json.headers['content-type'], 'application/json')
assert.equal(json.headers['cache-control'], 'no-store')
assert.equal((await v.get('/out/blob.bin')).headers['content-type'], 'application/octet-stream')
const download = await v.get('/out/a%22b.sdf?download')
assert.equal(download.headers['content-disposition'], `attachment; filename="ab.sdf"; filename*=UTF-8''a%22b.sdf`)
assert.equal(download.headers['content-type'], 'chemical/x-mdl-sdfile')
assert.equal((await v.get('/out')).status, 404)
assert.equal((await v.get('/out/missing.sdf')).status, 404)
const outside = await v.get('/%2e%2e/%2e%2e/etc/hosts')
assert.deepEqual([outside.status, JSON.parse(outside.body)], [404, { error: 'not found' }])
})
test('pane URLs load and download exact filenames containing URL punctuation', async () => {
for (const name of ['candidate #1', 'candidate ?2', 'candidate %3', 'α "lead" & analogue']) {
const folder = 'out/series #1'
for (const extension of ['.sdf', '.conformers.sdf', '.svg']) {
const path = `${folder}/${name}${extension}`
const content = `${name}${extension}\nexact workspace bytes`
put(v.ws, path, content)
const source = workspaceFileUrl(path, { v: 123 })
const url = new URL(source, `http://127.0.0.1:${v.port}`)
assert.equal(url.hash, '')
assert.equal(url.searchParams.get('v'), '123')
const loaded = await v.get(url.pathname + url.search)
assert.equal(loaded.status, 200, path)
assert.equal(loaded.body, content, path)
const saved = await v.get(workspaceFileUrl(path, { download: 1 }))
assert.equal(saved.status, 200, path)
assert.equal(saved.body, content, path)
assert.match(saved.headers['content-disposition'], /^attachment;/)
if (name.startsWith('α')) {
const encodedName = saved.headers['content-disposition'].split("filename*=UTF-8''")[1]
assert.equal(decodeURIComponent(encodedName), name + extension)
}
}
}
})
test('a malformed URL is an error answer, not a dead pane', async () => {
const bad = await v.get('/%E0%A4%A')
assert.equal(bad.status, 500)
assert.match(JSON.parse(bad.body).error, /URI malformed/)
const absolute = await new Promise((resolve) => { // an absolute-form target whose host is not a URL's
const socket = connect(v.port, '127.0.0.1', () => socket.write('GET http://[bad/x HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n'))
let text = ''
socket.on('data', (chunk) => { text += chunk })
socket.on('close', () => resolve(text))
})
assert.match(absolute, /^HTTP\/1\.1 500 .*"error":"Invalid URL"/s)
assert.equal((await v.get('/')).status, 200)
})
test('a file it cannot read is an error answer', { skip: process.getuid?.() === 0 && 'root reads everything' }, async () => {
chmodSync(put(v.ws, 'out/locked.sdf', 'secret'), 0o000)
const locked = await v.get('/out/locked.sdf').catch((error) => assert.fail(`${error.message}: ${v.output()}`))
assert.equal(locked.status, 500)
assert.match(JSON.parse(locked.body).error, /EACCES/)
const mol = await v.get('/api/mol?path=out/locked.sdf').catch((error) => assert.fail(`${error.message}: ${v.output()}`))
assert.equal(mol.status, 500)
assert.equal((await v.get('/')).status, 200)
})
})
describe('/api/mol', () => {
let v
before(async () => { v = await viewer() })
after(() => v.stop())
test('MOL exports retain Unicode and quoted molecule names', async () => {
const name = 'α "lead" #1'
put(v.ws, `out/${name}.sdf`, 'molecule\nM END\n$$$$\n')
const mol = await v.get('/api/mol?path=' + encodeURIComponent(`out/${name}.sdf`))
assert.equal(mol.status, 200)
assert.equal(mol.body, 'molecule\nM END\n')
assert.equal(decodeURIComponent(mol.headers['content-disposition'].split("filename*=UTF-8''")[1]), name + '.mol')
})
test('the first record as a MOL file, named for the molecule', async () => {
put(v.ws, 'out/x.conformers.sdf', 'x\n RDKit\n\n 0 0\nM END\n> <energy>\n1\n\n$$$$\nsecond\nM END\n')
const mol = await v.get('/api/mol?path=out/x.conformers.sdf')
assert.equal(mol.status, 200)
assert.equal(mol.body, 'x\n RDKit\n\n 0 0\nM END\n')
assert.equal(mol.headers['content-disposition'], 'attachment; filename="x.mol"')
put(v.ws, 'out/raw.mol', 'no end marker')
assert.equal((await v.get('/api/mol?path=out/raw.mol')).body, 'no end marker')
assert.equal((await v.get('/api/mol?path=out/none.sdf')).status, 404)
assert.equal((await v.get('/api/mol?path=out')).status, 404)
assert.equal((await v.get('/api/mol?path=../../etc/hosts')).status, 404)
assert.equal((await v.get('/api/mol')).status, 404)
})
})
describe('/api/series', () => {
test('an empty workspace has no series, no progress and no newest molecule', async () => {
const v = await viewer()
try {
const { status, body } = await v.json('/api/series')
assert.equal(status, 200)
assert.deepEqual(body, { dir: 'out', molecules: [], progress: null, newest: null, python: false })
assert.deepEqual((await v.json('/api/series?dir=../elsewhere')).body.molecules, [])
} finally { await v.stop() }
})
test('series.json in order, then the structures it does not list, each once', async () => {
const ws = mkdtempSync(join(scratch, 'ws-'))
const now = new Date().toISOString()
put(ws, 'out/lead.sdf', 'lead', 30)
put(ws, 'out/analogue.sdf', 'analogue', 30)
put(ws, 'out/old.sdf', 'old', 30)
put(ws, 'out/custom-name.sdf', 'custom', 30)
put(ws, 'out/undated.sdf', 'undated', 40)
put(ws, 'out/series.json', JSON.stringify({ molecules: [
{ name: 'undated', properties: { mw: 3 } },
null, { smiles: 'C' },
{ name: 'lead', createdAt: '2026-01-01T00:00:00Z', updatedAt: now, properties: { mw: 1 } },
{ name: 'analogue', createdAt: '2026-01-02T00:00:00Z', updatedAt: '2020-01-01T00:00:00Z', properties: { mw: 2 } },
{ name: 'old', createdAt: '2026-01-03T00:00:00Z', updatedAt: now, legacy: true, properties: {} },
{ name: 'custom', sdf: 'custom-name.sdf', createdAt: 'not a date', updatedAt: now },
{ name: 'gone', createdAt: '2026-01-04T00:00:00Z', updatedAt: now, properties: {} },
] }))
put(ws, 'out/lead.pdb', 'same stem as a listed molecule', 10)
put(ws, 'out/hand.mol', 'hand', 5)
put(ws, 'out/hand.pdb', 'the same molecule, lower rank', 5)
put(ws, 'out/scaffold.mol2', 'scaffold', 1)
put(ws, 'out/hand.conformers.sdf', 'ensemble')
put(ws, 'out/.hidden.sdf', 'hidden')
put(ws, 'out/notes.txt', 'notes')
mkdirSync(join(ws, 'out/folder.pdb'))
const v = await viewer({ workspace: ws, env: { RDKIT_PYTHON: FAKE_PYTHON } })
try {
const { body } = await v.json('/api/series?dir=out')
// Ordered by createdAt, or the file's time when that is not a date; listed first only by date.
assert.deepEqual(body.molecules.map((m) => [m.name, m.sdf, m.stale, m.legacy]), [
['lead', 'out/lead.sdf', false, false],
['analogue', 'out/analogue.sdf', true, false], // written before its SDF last changed
['old', 'out/old.sdf', true, true],
['undated', 'out/undated.sdf', true, false], // no updatedAt: nothing says the record is this file's
['custom', 'out/custom-name.sdf', false, true], // no properties: an entry from before they were recorded
['hand', 'out/hand.mol', undefined, true], // .mol outranks .pdb for the same stem
['scaffold', 'out/scaffold.mol2', undefined, true],
])
assert.equal(body.python, true)
assert.equal(body.newest, 'out/scaffold.mol2')
} finally { await v.stop() }
})
test('a folder it may enter but not list still shows what series.json names', { skip: process.getuid?.() === 0 && 'root lists everything' }, async () => {
const ws = mkdtempSync(join(scratch, 'ws-'))
put(ws, 'locked/a.sdf', 'a')
put(ws, 'locked/b.sdf', 'b')
put(ws, 'locked/series.json', JSON.stringify({ molecules: [{ name: 'a', updatedAt: new Date().toISOString(), properties: {} }] }))
chmodSync(join(ws, 'locked'), 0o311)
const v = await viewer({ workspace: ws })
try {
assert.deepEqual((await v.json('/api/series?dir=locked')).body.molecules.map((m) => m.name), ['a'])
} finally { await v.stop(); chmodSync(join(ws, 'locked'), 0o755) }
})
test('the newest structure anywhere near the top, skipping what is not the agent\'s', async () => {
const ws = mkdtempSync(join(scratch, 'ws-'))
put(ws, 'out/a.sdf', 'a', 100)
put(ws, 'deep/1/2/3/b.pdb', 'b', 50)
put(ws, 'deep/1/2/3/4/5/too-deep.sdf', 'deep')
put(ws, 'molecules/script-output.sdf', 'not an artifact')
put(ws, 'node_modules/pkg/test.sdf', 'no')
put(ws, '.cache/x.sdf', 'no')
put(ws, 'out/b.conformers.sdf', 'ensemble')
put(ws, 'out/readme.md', 'text')
symlinkSync(join(ws, 'nowhere.sdf'), join(ws, 'out/broken.sdf'))
mkdirSync(join(ws, 'closed'))
chmodSync(join(ws, 'closed'), 0o000)
const v = await viewer({ workspace: ws })
try {
const { body } = await v.json('/api/series')
assert.equal(body.newest, 'deep/1/2/3/b.pdb')
assert.equal(body.dir, 'deep/1/2/3')
assert.deepEqual(body.molecules.map((m) => m.name), ['b'])
} finally { await v.stop(); chmodSync(join(ws, 'closed'), 0o755) }
})
test('progress: finished, running, and a run that died or went quiet', async () => {
const dead = spawn(process.execPath, ['-e', ''])
await new Promise((resolve) => dead.on('exit', resolve))
const v = await viewer()
const progress = async (record, dir) => {
put(v.ws, `${dir ?? 'out'}/.progress.json`, JSON.stringify(record))
return (await v.json(`/api/series${dir ? `?dir=${dir}` : '?dir=out'}`)).body.progress
}
const at = Date.now() / 1000
try {
assert.equal((await progress({ stage: 'done', pid: dead.pid, at: 0 })).stage, 'done')
assert.equal((await progress({ stage: 'failed', at: 0 })).stage, 'failed')
assert.equal((await progress({ stage: 'embedding', pid: process.pid, at })).stage, 'embedding')
assert.equal((await progress({ stage: 'embedding', pid: dead.pid, at })).stage, 'stopped')
assert.equal((await progress({ stage: 'writing', at })).stage, 'writing')
assert.equal((await progress({ stage: 'writing', pid: process.pid })).stage, 'stopped') // no timestamp: long gone
assert.equal((await progress({ stage: 'embedding', pid: 1, at }, 'series2')).stage, 'embedding') // not ours to signal, but alive
put(v.ws, 'out/.progress.json', '{torn')
assert.equal((await v.json('/api/series?dir=out')).body.progress, null)
} finally { await v.stop() }
})
})
describe('/api/molecule', () => {
test('the toolchain\'s record when it is this SDF\'s, with its depiction', async () => {
const v = await viewer()
try {
put(v.ws, 'out/a.sdf', 'A-sdf')
put(v.ws, 'out/a.conformers.sdf', 'A-ensemble')
put(v.ws, 'out/drawn.svg', '<svg/>')
put(v.ws, 'out/a.molecule.json', JSON.stringify({ spec: 'rdkit-molecule/1', name: 'a', svg: 'drawn.svg', sdfSha1: sha1('A-sdf') }))
const { status, body } = await v.json('/api/molecule?path=out/a.sdf')
assert.equal(status, 200)
assert.deepEqual([body.name, body.svgText, body.computedBy], ['a', '<svg/>', 'toolchain'])
assert.equal((await v.json('/api/molecule?path=out/a.conformers.sdf')).body.computedBy, 'toolchain') // hashed against a.sdf
put(v.ws, 'out/b.pdb', 'B-pdb')
put(v.ws, 'out/b.molecule.json', JSON.stringify({ spec: 'rdkit-molecule/1', name: 'b', sdfSha1: sha1('B-pdb') }))
const b = await v.json('/api/molecule?path=out/b.pdb')
assert.deepEqual([b.body.computedBy, b.body.svgText], ['toolchain', undefined]) // no b.svg: the depiction is optional
put(v.ws, 'out/c.mol', 'C')
put(v.ws, 'out/c.molecule.json', JSON.stringify({ spec: 'rdkit-molecule/1', name: 'c' }))
assert.equal((await v.json('/api/molecule?path=out/c.mol')).body.computedBy, 'toolchain') // no hash to check
} finally { await v.stop() }
})
test('what is not a structure in the workspace is not found', async () => {
const v = await viewer()
try {
put(v.ws, 'out/notes.txt', 'text')
for (const path of ['out/none.sdf', 'out', 'out/notes.txt', '../../etc/hosts', '']) {
const { status, body } = await v.json(`/api/molecule?path=${path}`)
assert.equal(status, 404, path)
assert.match(body.error, /is not there/)
}
} finally { await v.stop() }
})
test('without a Python for RDKit the pane says how to get one', { skip: existsSync(join(PKG, '.venv/bin/python')) && 'this package has its own .venv' }, async () => {
const v = await viewer()
try {
put(v.ws, 'out/x.sdf', 'x')
const { status, body } = await v.json('/api/molecule?path=out/x.sdf')
assert.deepEqual([status, body.error], [422, 'RDKit is not installed for the pane (run toolchain/setup.sh)'])
} finally { await v.stop() }
})
test('the worker describes a stale or foreign SDF, once per version of the file', async () => {
writeFileSync(WORKER_LOG, '')
const dsh = mkdtempSync(join(scratch, 'dsh-'))
mkdirSync(join(dsh, '.venv/bin'), { recursive: true })
symlinkSync(FAKE_PYTHON, join(dsh, '.venv/bin/python'))
const v = await viewer({ env: { HARNESS_DSH_DIR: dsh } })
try {
put(v.ws, 'out/hand.sdf', 'hand')
put(v.ws, 'out/hand.molecule.json', JSON.stringify({ spec: 'rdkit-molecule/1', name: 'hand', sdfSha1: 'an older sdf' }))
const first = await v.json('/api/molecule?path=out/hand.sdf')
assert.equal(first.status, 200, JSON.stringify(first.body))
assert.deepEqual([first.body.name, first.body.computedBy, first.body.op], ['hand.sdf', 'viewer', 'describe'])
assert.deepEqual(first.body.argv, ['-u', join(PKG, 'toolchain/harness_rdkit.py'), 'serve'])
assert.equal(first.body.pythonpath, join(PKG, 'toolchain'))
assert.equal((await v.json('/api/molecule?path=out/hand.sdf')).body.name, 'hand.sdf')
put(v.ws, 'out/hand.sdf', 'hand, edited')
put(v.ws, 'out/other.molecule.json', '{"spec": "something else"}')
put(v.ws, 'out/other.sdf', 'other')
await v.json('/api/molecule?path=out/hand.sdf')
await v.json('/api/molecule?path=out/other.sdf')
await sleep(100)
assert.deepEqual((await import('node:fs')).readFileSync(WORKER_LOG, 'utf8').trim().split('\n'),
[`start -u ${join(PKG, 'toolchain/harness_rdkit.py')} serve`, 'ask hand.sdf', 'ask hand.sdf', 'ask other.sdf'])
assert.match(v.output(), /\[rdkit\] worker: warming up/)
} finally { await v.stop() }
})
test('a failure is reported and not cached; a dead worker is replaced; a silent one times out', async () => {
writeFileSync(WORKER_LOG, '')
const v = await viewer({ env: { RDKIT_PYTHON: FAKE_PYTHON, TEST_ASK_TIMEOUT_MS: '1500' } })
const ask = (path) => v.json(`/api/molecule?path=${path}`)
try {
for (const name of ['fail.sdf', 'blank.sdf', 'crash.sdf', 'crash2.sdf', 'slow.sdf', 'fine.sdf']) put(v.ws, `out/${name}`, name)
assert.deepEqual(await ask('out/fail.sdf').then((r) => [r.status, r.body.error]), [422, 'ValueError: no molecule'])
assert.deepEqual(await ask('out/fail.sdf').then((r) => [r.status, r.body.error]), [422, 'ValueError: no molecule'])
assert.deepEqual(await ask('out/blank.sdf').then((r) => [r.status, r.body.error]), [422, 'describe failed'])
assert.deepEqual(await ask('out/crash.sdf').then((r) => [r.status, r.body.error]), [422, 'the RDKit worker stopped'])
assert.equal((await ask('out/fine.sdf')).status, 200) // a new worker
assert.deepEqual(await ask('out/slow.sdf').then((r) => [r.status, r.body.error]), [422, 'RDKit took longer than 60 s'])
// A request the file changed under: the newer one owns the cache, the older one's failure leaves it be.
const older = ask('out/slow.sdf')
await sleep(50)
put(v.ws, 'out/slow.sdf', 'slow, edited')
const newer = ask('out/slow.sdf')
assert.deepEqual((await Promise.all([older, newer])).map((r) => r.status), [422, 422])
const log = (await import('node:fs')).readFileSync(WORKER_LOG, 'utf8').trim().split('\n')
assert.equal(log.filter((line) => line === 'ask fail.sdf').length, 2)
assert.equal(log.filter((line) => line.startsWith('start')).length, 2)
} finally { await v.stop() }
})
test('an SDF it cannot read is described afresh, not matched to a record', { skip: process.getuid?.() === 0 && 'root reads everything' }, async () => {
const v = await viewer({ env: { RDKIT_PYTHON: FAKE_PYTHON } })
try {
chmodSync(put(v.ws, 'out/locked.sdf', 'locked'), 0o000)
put(v.ws, 'out/locked.molecule.json', JSON.stringify({ spec: 'rdkit-molecule/1', name: 'locked', sdfSha1: sha1('locked') }))
const { status, body } = await v.json('/api/molecule?path=out/locked.sdf')
assert.deepEqual([status, body.computedBy], [200, 'viewer'])
} finally { await v.stop() }
})
test('a Python that cannot be started is an answer, not a dead pane', async () => {
const notExecutable = put(scratch, 'not-executable-python', 'x')
chmodSync(notExecutable, 0o644)
const v = await viewer({ env: { RDKIT_PYTHON: notExecutable } })
try {
put(v.ws, 'out/x.sdf', 'x')
put(v.ws, 'out/y.sdf', 'y')
assert.deepEqual(await v.json('/api/molecule?path=out/x.sdf').then((r) => [r.status, r.body.error]), [422, 'the RDKit worker stopped'])
assert.deepEqual(await v.json('/api/molecule?path=out/y.sdf').then((r) => [r.status, r.body.error]), [422, 'the RDKit worker stopped'])
assert.equal(v.child.exitCode, null)
} finally { await v.stop() }
})
})
describe('live', () => {
test('changes are batched, noise is ignored, progress is pushed, and clients are pinged', async () => {
const v = await viewer({ env: { TEST_PING_MS: '100' } })
const stream = events(v.port)
try {
await stream.ready
assert.match(stream.text(), /^: hello/)
await sleep(300) // let the watcher settle on the fresh workspace
put(v.ws, '.harness/verdict.json', '{}')
put(v.ws, 'node_modules/x.js', '')
put(v.ws, '__pycache__/x.pyc', '')
put(v.ws, 'out/.x.sdf.123.tmp', '')
put(v.ws, 'out/one.sdf', '1')
await sleep(40)
put(v.ws, 'out/two.sdf', '2')
const change = await stream.until((text) => /event: change\ndata: .*two\.sdf/.test(text))
const files = JSON.parse(change.match(/event: change\ndata: (.*)\n/)[1]).files
assert.ok(files.includes('out/one.sdf') && files.includes('out/two.sdf'), files.join(','))
assert.ok(!files.some((f) => /harness|node_modules|pycache|\.tmp$/.test(f)), files.join(','))
put(v.ws, 'out/.progress.json', JSON.stringify({ stage: 'done', name: 'x' }))
const pushed = await stream.until((text) => text.includes('event: progress'))
assert.match(pushed, /event: progress\ndata: {"dir":"out","progress":{"stage":"done","name":"x"}}/)
await stream.until((text) => text.includes(': ping'))
} finally { stream.close(); await sleep(50); await v.stop() }
})
test('a workspace it cannot watch still serves', async () => {
const v = await viewer({ workspace: join(scratch, 'does-not-exist') })
try {
assert.match(v.output(), /\[rdkit\] watch failed: /)
assert.equal((await v.json('/api/series')).body.newest, null)
} finally { await v.stop() }
})
test('SIGTERM and SIGINT stop it cleanly, with its worker', async () => {
writeFileSync(WORKER_LOG, '')
const v = await viewer({ env: { RDKIT_PYTHON: FAKE_PYTHON } })
put(v.ws, 'out/fine.sdf', 'fine')
assert.equal((await v.json('/api/molecule?path=out/fine.sdf')).status, 200)
assert.deepEqual(await v.stop('SIGTERM'), { code: 0, signal: null })
const w = await viewer()
assert.deepEqual(await w.stop('SIGINT'), { code: 0, signal: null })
})
})