The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
import { beforeEach, expect, it, vi } from 'vitest'
import type * as ClientApi from './client'
vi.mock('@/lib/legacy-session-owner-backfill', () => ({ maybeBackfillLegacySessionOwners: vi.fn() }))
vi.mock('@/store/transcript-tail', () => ({ recordTranscriptTail: vi.fn() }))
vi.mock('./client', async importOriginal => ({
...await importOriginal<typeof ClientApi>(), hermesApi: vi.fn()
}))
import { hermesApi, setApiRequestConnection, setApiRequestProfile } from './client'
import { deleteSession, renameSession, setSessionArchived, setSessionPinnedRemote, setSessionUnreadRemote } from './sessions'
beforeEach(() => { vi.mocked(hermesApi).mockReset(); setApiRequestConnection('owner'); setApiRequestProfile('work') })
it('concurrent equal sidebar edits share the missing-snapshot verdict on older standalone servers', async () => {
vi.mocked(hermesApi).mockImplementation(async request => {
if (!request.method || request.method === 'GET') {
throw new Error('404: {"detail":"No such API endpoint: /api/sessions/shared-old/mutation-snapshot"}')
}
return { ok: true } as never
})
const results = await Promise.allSettled([
renameSession('shared-old', 'same name', 'work'),
renameSession('shared-old', 'same name', 'work')
])
expect(results.map(result => result.status)).toEqual(['fulfilled', 'fulfilled'])
expect(vi.mocked(hermesApi).mock.calls.filter(([request]) => !request.method || request.method === 'GET')).toHaveLength(1)
})
it('a missing-route response from a write never selects an unfenced retry', async () => {
const missing = new Error('404: {"detail":"No such API endpoint: /api/sessions/write-only"}')
const writes: unknown[] = []
vi.mocked(hermesApi).mockImplementation(async request => {
if (!request.method || request.method === 'GET') {
return { exists: true, runtime_revision: 2, runtime_generation: 1 } as never
}
writes.push(request.body)
throw missing
})
await expect(renameSession('write-only', 'same name', 'work')).rejects.toBe(missing)
expect(writes).toHaveLength(1)
expect(writes[0]).toMatchObject({ request_id: expect.any(String), expected_revision: 2 })
})
it('uses owner snapshots and preserves the exact delete identity after a lost reply', async () => {
let lost = true
const writes: unknown[] = []
vi.mocked(hermesApi).mockImplementation(async request => {
if (!request.method || request.method === 'GET') {
return { exists: true, runtime_revision: 12, runtime_generation: 8 } as never
}
writes.push(request)
if (lost) { lost = false; throw new Error('network disconnected after commit') }
return { deleted_ids: ['delete-me'], revision: 13 } as never
})
const owner = { connectionId: 'server', profile: 'work' }
await expect(deleteSession('delete-me', owner)).rejects.toThrow('network disconnected')
setApiRequestConnection('unrelated')
await deleteSession('delete-me', owner)
expect(writes).toHaveLength(2)
expect(writes[1]).toEqual(writes[0])
const request = writes[0] as { path: string; connectionId: string }
const url = new URL(request.path, 'http://localhost')
expect(request.connectionId).toBe('server')
expect(url.searchParams.get('expected_revision')).toBe('12')
expect(url.searchParams.get('expected_generation')).toBe('8')
expect(url.searchParams.get('request_id')).toBeTruthy()
})
it('all sidebar mutations use real counters and surface conflicts without a blind write', async () => {
const calls = [() => renameSession('sidebar', 'name', 'work'),
() => setSessionArchived('sidebar', true, 'work'), () => setSessionPinnedRemote('sidebar', false, 'work'),
() => setSessionUnreadRemote('sidebar', true, 'work')]
vi.mocked(hermesApi).mockImplementation(async request => {
if (!request.method || request.method === 'GET') {
return { exists: true, runtime_revision: 19, runtime_generation: 4 } as never
}
expect(request.body).toMatchObject({ expected_revision: 19, expected_generation: 4,
request_id: expect.any(String), profile: 'work' })
throw new Error('revision_conflict')
})
for (const invoke of calls) { await expect(invoke()).rejects.toThrow('revision_conflict') }
vi.mocked(hermesApi).mockReset().mockResolvedValue({ exists: true } as never)
await expect(renameSession('unknown-counter', 'name')).rejects.toThrow(/snapshot/)
expect(hermesApi).toHaveBeenCalledTimes(1)
})
// R12: an older standalone runtime has no fencing route (its SPA catch-all answers the exact
// marker below); sidebar edits there keep the base write. Any other refusal of the snapshot read
// (a profile 404, permission, timeout, an unavailable authority) is never a downgrade.
it('sidebar edits fall back to the base write only when the backend lacks the fencing route', async () => {
const routeMissing = '404: {"detail":"No such API endpoint: /api/sessions/old/mutation-snapshot"}'
const writes: Array<{ path: string; method?: string; body?: unknown }> = []
vi.mocked(hermesApi).mockImplementation(async request => {
if (!request.method || request.method === 'GET') { throw new Error(routeMissing) }
writes.push(request as never)
return { ok: true } as never
})
await renameSession('old', 'name', 'work')
await setSessionArchived('old', true, 'work')
await setSessionPinnedRemote('old', true, 'work')
await setSessionUnreadRemote('old', false, 'work')
await deleteSession('old', { connectionId: 'server', profile: 'work' })
expect(writes.map(write => [write.method, write.body])).toEqual([
['PATCH', { title: 'name', profile: 'work' }], ['PATCH', { archived: true, pinned: false, profile: 'work' }],
['PATCH', { pinned: true, profile: 'work' }], ['PATCH', { unread: false, profile: 'work' }], ['DELETE', undefined]])
expect(new URL(writes[4].path, 'http://localhost').search).toBe('?profile=work')
for (const refusal of ['404: {"detail":"Profile \'work\' does not exist."}', '403: permission_denied',
'503: {"detail":"session_authority_unavailable"}', 'Request timed out']) {
writes.length = 0
vi.mocked(hermesApi).mockReset().mockImplementation(async request => {
if (!request.method || request.method === 'GET') { throw new Error(refusal) }
writes.push(request as never)
return { ok: true } as never
})
await expect(renameSession('old', 'name', 'work')).rejects.toThrow(refusal)
expect(writes).toEqual([])
}
})
// N21: an older headless `hermes serve` (SSH remotes) answers an unmatched GET with its own fixed
// catch-all body, formatted by Electron's httpStatusError. That is the same route verdict.
it('sidebar edits on an older headless serve fall back to the base write', async () => {
const headless = '404: {"error":"Headless backend (hermes serve): web UI disabled \u2014 use `hermes dashboard` for the browser UI."}'
const writes: Array<{ method?: string; body?: unknown }> = []
vi.mocked(hermesApi).mockReset().mockImplementation(async request => {
if (!request.method || request.method === 'GET') { throw new Error(headless) }
writes.push(request as never)
return { ok: true } as never
})
await renameSession('ssh', 'name', 'work')
await setSessionArchived('ssh', true, 'work')
await setSessionPinnedRemote('ssh', true, 'work')
await setSessionUnreadRemote('ssh', false, 'work')
await deleteSession('ssh', { connectionId: 'server', profile: 'work' })
expect(writes.map(write => [write.method, write.body])).toEqual([
['PATCH', { title: 'name', profile: 'work' }], ['PATCH', { archived: true, pinned: false, profile: 'work' }],
['PATCH', { pinned: true, profile: 'work' }], ['PATCH', { unread: false, profile: 'work' }], ['DELETE', undefined]])
// FastAPI's bare 404 is no route verdict: it keeps the fenced path and writes nothing.
writes.length = 0
vi.mocked(hermesApi).mockReset().mockImplementation(async request => {
if (!request.method || request.method === 'GET') { throw new Error('404: {"detail":"Not Found"}') }
writes.push(request as never)
return { ok: true } as never
})
await expect(renameSession('ssh', 'name', 'work')).rejects.toThrow('Not Found')
expect(writes).toEqual([])
})