mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
237 lines
7.6 KiB
TypeScript
237 lines
7.6 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import { type ChildProcess, spawn } from 'node:child_process'
|
|
import { once } from 'node:events'
|
|
|
|
import { test } from 'vitest'
|
|
|
|
import { waitForBackendExit } from './backend-child'
|
|
import { createBackendConnectionState } from './backend-connection-state'
|
|
|
|
type FakeProcess = { id: string }
|
|
|
|
function deferred<T>() {
|
|
let resolve!: (value: T) => void
|
|
|
|
const promise = new Promise<T>(next => {
|
|
resolve = next
|
|
})
|
|
|
|
return { promise, resolve }
|
|
}
|
|
|
|
test('an invalidated remote attempt cannot publish a late descriptor', async () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const oldProbe = deferred<string>()
|
|
const oldAttempt = state.startAttempt()
|
|
|
|
const oldResult = oldProbe.promise.then(descriptor => {
|
|
if (!state.isCurrentAttempt(oldAttempt)) {
|
|
throw new Error('Hermes backend start was superseded by a newer connection attempt.')
|
|
}
|
|
|
|
return descriptor
|
|
})
|
|
|
|
state.setPromise(oldAttempt, oldResult)
|
|
state.invalidate()
|
|
|
|
const newAttempt = state.startAttempt()
|
|
const newResult = Promise.resolve('https://new.example')
|
|
|
|
state.setPromise(newAttempt, newResult)
|
|
assert.equal(await newResult, 'https://new.example')
|
|
|
|
oldProbe.resolve('https://old.example')
|
|
await assert.rejects(oldResult, /superseded by a newer connection attempt/)
|
|
assert.equal(state.getPromise(), newResult)
|
|
})
|
|
|
|
test('a stale backend exit cannot clear a newer connection attempt', () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const oldAttempt = state.startAttempt()
|
|
const oldPromise = Promise.resolve('old')
|
|
|
|
state.setPromise(oldAttempt, oldPromise)
|
|
const oldOwner = state.attachProcess(oldAttempt, { id: 'old' })
|
|
assert.ok(oldOwner)
|
|
|
|
state.invalidate()
|
|
|
|
const newAttempt = state.startAttempt()
|
|
const newPromise = Promise.resolve('new')
|
|
const newProcess = { id: 'new' }
|
|
|
|
state.setPromise(newAttempt, newPromise)
|
|
assert.ok(state.attachProcess(newAttempt, newProcess))
|
|
|
|
assert.equal(state.clearForCurrentProcess(oldOwner), false)
|
|
assert.equal(state.getProcess(), newProcess)
|
|
assert.equal(state.getPromise(), newPromise)
|
|
})
|
|
|
|
test('the current backend exit clears its process and connection promise', () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const attempt = state.startAttempt()
|
|
|
|
state.setPromise(attempt, Promise.resolve('current'))
|
|
const owner = state.attachProcess(attempt, { id: 'current' })
|
|
assert.ok(owner)
|
|
|
|
assert.equal(state.clearForCurrentProcess(owner), true)
|
|
assert.equal(state.clearPromiseForAttempt(attempt), true)
|
|
assert.equal(state.getProcess(), null)
|
|
assert.equal(state.getPromise(), null)
|
|
})
|
|
|
|
test('a stale rejected attempt cannot clear a newer connection promise', () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const oldAttempt = state.startAttempt()
|
|
|
|
state.setPromise(oldAttempt, Promise.resolve('old'))
|
|
state.invalidate()
|
|
|
|
const newAttempt = state.startAttempt()
|
|
const newPromise = Promise.resolve('new')
|
|
|
|
state.setPromise(newAttempt, newPromise)
|
|
|
|
assert.equal(state.clearPromiseForAttempt(oldAttempt), false)
|
|
assert.equal(state.getPromise(), newPromise)
|
|
})
|
|
|
|
test('an invalidated attempt cannot attach a late-spawned process', () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const staleAttempt = state.startAttempt()
|
|
|
|
state.invalidate()
|
|
|
|
assert.equal(state.attachProcess(staleAttempt, { id: 'late' }), null)
|
|
assert.equal(state.getProcess(), null)
|
|
})
|
|
|
|
test('a failed primary stop retains its child and blocks a replacement until retry exits', async () => {
|
|
const state = createBackendConnectionState<ChildProcess, string>()
|
|
|
|
const child = spawn(process.execPath, ['-e', 'process.stdout.write("ready"); setInterval(() => {}, 1000)'], {
|
|
stdio: ['ignore', 'pipe', 'ignore'],
|
|
windowsHide: true
|
|
})
|
|
|
|
try {
|
|
await once(child.stdout!, 'data')
|
|
const attempt = state.startAttempt()
|
|
state.setPromise(attempt, Promise.resolve('ready'))
|
|
const owner = state.attachProcess(attempt, child)
|
|
assert.ok(owner)
|
|
const failure = new Error('primary is still running')
|
|
const calls: ChildProcess[] = []
|
|
|
|
const fail = async (current: ChildProcess): Promise<void> => {
|
|
calls.push(current)
|
|
throw failure
|
|
}
|
|
|
|
const stopping = state.stopProcess(fail)
|
|
assert.equal(state.getProcess(), null)
|
|
assert.equal(state.getPromise(), null)
|
|
assert.equal(state.getPendingPromise(), null)
|
|
assert.throws(() => state.startAttempt(), /has not stopped/)
|
|
assert.equal(state.stopProcess(fail), stopping)
|
|
await assert.rejects(stopping, error => error === failure)
|
|
state.invalidate()
|
|
assert.throws(() => state.startAttempt(), /has not stopped/)
|
|
assert.equal(child.exitCode, null)
|
|
assert.equal(child.signalCode, null)
|
|
|
|
await state.stopProcess(async current => {
|
|
calls.push(current)
|
|
current.kill()
|
|
await waitForBackendExit(current, {
|
|
forceKillProcessTree: (): void => {
|
|
current.kill('SIGKILL')
|
|
},
|
|
killGroup: (): void => {
|
|
current.kill('SIGKILL')
|
|
}
|
|
})
|
|
})
|
|
assert.deepEqual(calls, [child, child])
|
|
assert.ok(child.exitCode !== null || child.signalCode !== null)
|
|
const replacement = state.startAttempt()
|
|
const connection = Promise.resolve('new')
|
|
assert.equal(state.setPromise(replacement, connection), true)
|
|
assert.equal(state.clearForCurrentProcess(owner), false)
|
|
assert.equal(state.getPromise(), connection)
|
|
} finally {
|
|
if (child.exitCode === null && child.signalCode === null) {
|
|
const closed = once(child, 'close')
|
|
child.kill()
|
|
await closed
|
|
}
|
|
}
|
|
}, 15_000)
|
|
|
|
test('shutdown sees a spawned child while its persistent claim is still pending', async () => {
|
|
const state = createBackendConnectionState<ChildProcess, string>()
|
|
|
|
const child = spawn(process.execPath, ['-e', 'process.stdout.write("ready"); setInterval(() => {}, 1000)'], {
|
|
stdio: ['ignore', 'pipe', 'ignore'],
|
|
windowsHide: true
|
|
})
|
|
|
|
const claim = deferred<void>()
|
|
|
|
try {
|
|
await once(child.stdout!, 'data')
|
|
const attempt = state.startAttempt()
|
|
|
|
const claiming = state.claimProcess(attempt, child, async current => {
|
|
assert.equal(current, child)
|
|
assert.equal(state.getProcess(), child)
|
|
await claim.promise
|
|
})
|
|
|
|
assert.equal(state.getProcess(), child)
|
|
await state.stopProcess(async current => {
|
|
assert.equal(current, child)
|
|
current.kill()
|
|
await waitForBackendExit(current, {
|
|
forceKillProcessTree: (): void => {
|
|
current.kill('SIGKILL')
|
|
},
|
|
killGroup: (): void => {
|
|
current.kill('SIGKILL')
|
|
}
|
|
})
|
|
})
|
|
assert.ok(child.exitCode !== null || child.signalCode !== null)
|
|
claim.resolve()
|
|
assert.equal(await claiming, null, 'a completed claim cannot revive the stopped generation')
|
|
assert.equal(state.getProcess(), null)
|
|
assert.doesNotThrow(() => state.startAttempt())
|
|
} finally {
|
|
claim.resolve()
|
|
|
|
if (child.exitCode === null && child.signalCode === null) {
|
|
const closed = once(child, 'close')
|
|
child.kill()
|
|
await closed
|
|
}
|
|
}
|
|
}, 15_000)
|
|
|
|
test('distinguishes a pending connection attempt from a cached settled descriptor', async () => {
|
|
const state = createBackendConnectionState<FakeProcess, string>()
|
|
const connection = deferred<string>()
|
|
const attempt = state.startAttempt()
|
|
|
|
state.setPromise(attempt, connection.promise)
|
|
assert.equal(state.getPendingPromise(), connection.promise)
|
|
|
|
connection.resolve('https://remote.example')
|
|
await connection.promise
|
|
await Promise.resolve()
|
|
|
|
assert.equal(state.getPromise(), connection.promise)
|
|
assert.equal(state.getPendingPromise(), null)
|
|
})
|