mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
150 lines
5.6 KiB
TypeScript
150 lines
5.6 KiB
TypeScript
/**
|
|
* Failure class: APP-DRIVEN UPDATE completes.
|
|
*
|
|
* A user on a healthy local install (scripts/install.sh + `hermes desktop`)
|
|
* sees "Update now" in Settings → About when upstream main moves, clicks it,
|
|
* and the app hands off to the updater, quits, updates, and comes back:
|
|
* - the backend checkout is on the new upstream commit, clean;
|
|
* - the app relaunched by itself (a new Desktop process from the rebuilt
|
|
* package, with its own backend) and logged the update as finished OK;
|
|
* - the updated app boots to chat and a chat turn completes;
|
|
* - the updated app reports itself current (no update offered again).
|
|
*
|
|
* Real entry points only: the About panel's button and the app's own
|
|
* hand-off (scripts/desktop-update/posix.sh → `hermes update`). Fakes: the git
|
|
* server (local bare origin) and the LLM provider.
|
|
*/
|
|
|
|
import * as fs from 'node:fs'
|
|
|
|
import { expect, test } from '@playwright/test'
|
|
|
|
import { recordWebSockets, send, waitForInteractive } from '../core/harness'
|
|
|
|
import {
|
|
backendServeProcesses,
|
|
clickUpdateNowAndExpectHandoff,
|
|
closeQuietly,
|
|
currentAs,
|
|
desktopLog,
|
|
desktopMainProcesses,
|
|
diagnostics,
|
|
git,
|
|
handoffLog,
|
|
installProcesses,
|
|
launchInstalledApp,
|
|
openAbout,
|
|
publishUpstream,
|
|
startInstallSession,
|
|
waitFor,
|
|
waitForUpdateOffer
|
|
} from './harness'
|
|
|
|
const RUN = Date.now().toString(36)
|
|
const U = (n: number) => `U${n}-${RUN}`
|
|
const A = (n: number) => `A${n}-${RUN}`
|
|
|
|
test('clicking Update now moves the backend to the new commit, relaunches the app, and chat works after', async () => {
|
|
test.setTimeout(20 * 60_000)
|
|
const session = await startInstallSession()
|
|
const { facts, provider, env } = session
|
|
const before = git(facts.checkout, 'rev-parse', 'HEAD')
|
|
const target = publishUpstream('release: next upstream main', 'UPSTREAM_RELEASE.md', `next release ${RUN}\n`)
|
|
const explain = (extra = '') => diagnostics(facts, extra)
|
|
|
|
try {
|
|
let firstMainPid = 0
|
|
|
|
await test.step('the running app offers the new upstream commit and hands off on click', async () => {
|
|
const launched = await launchInstalledApp(facts, env)
|
|
firstMainPid = launched.app.process().pid ?? 0
|
|
await waitForInteractive(launched.app, launched.page).catch(error => {
|
|
throw new Error(`${(error as Error).message}\n${explain(launched.logTail())}`)
|
|
})
|
|
await openAbout(launched.page)
|
|
await waitForUpdateOffer(launched.page, target)
|
|
await clickUpdateNowAndExpectHandoff(launched, facts)
|
|
})
|
|
|
|
await test.step('the update lands and the app relaunches itself', async () => {
|
|
await waitFor(
|
|
'the updater to finish `hermes update`',
|
|
() => /hermes update exit code: \d+/.test(handoffLog(facts)),
|
|
{
|
|
timeout: 8 * 60_000,
|
|
interval: 2_000,
|
|
explain: () => explain(`handoff log:\n${handoffLog(facts)}`)
|
|
}
|
|
)
|
|
expect(handoffLog(facts), `the updater's hermes update succeeded\n${explain()}`).toMatch(
|
|
/hermes update exit code: 0\s*$|retry exit code: 0/m
|
|
)
|
|
expect(git(facts.checkout, 'rev-parse', 'HEAD'), 'the backend checkout is on the new upstream commit').toBe(
|
|
target
|
|
)
|
|
|
|
// The updater's progress window can be the same Electron binary (--app=http://127.0.0.1:...): not a relaunch.
|
|
const relaunched = await waitFor(
|
|
'the app to relaunch itself',
|
|
() =>
|
|
desktopMainProcesses(facts).find(
|
|
proc => proc.pid !== firstMainPid && !/--app=|https?:\/\/127\.0\.0\.1/.test(proc.cmdline)
|
|
),
|
|
{ timeout: 3 * 60_000, interval: 1_000, explain: () => explain(`handoff log:\n${handoffLog(facts)}`) }
|
|
)
|
|
|
|
await waitFor(
|
|
'the relaunched app to log the update result',
|
|
() => /\[updates\] detached update (finished|FAILED)/.test(desktopLog(facts)),
|
|
{
|
|
timeout: 3 * 60_000,
|
|
explain
|
|
}
|
|
)
|
|
expect(desktopLog(facts), `the relaunched app reports the update as finished OK\n${explain()}`).toMatch(
|
|
/\[updates\] detached update finished OK/
|
|
)
|
|
await waitFor('the relaunched app to start its backend', () => backendServeProcesses(facts).length > 0, {
|
|
timeout: 3 * 60_000,
|
|
explain
|
|
})
|
|
expect(
|
|
git(facts.checkout, 'status', '--porcelain', '--untracked-files=no'),
|
|
'the updated checkout is clean'
|
|
).toBe('')
|
|
|
|
// Hand the machine back to Playwright: quit the relaunched app the way the OS asks it to.
|
|
process.kill(relaunched.pid, 'SIGTERM')
|
|
await expect
|
|
.poll(() => installProcesses(facts).map(p => `${p.pid} ${p.cmdline.slice(0, 160)}`), {
|
|
timeout: 60_000,
|
|
message: 'the relaunched app quits cleanly on SIGTERM'
|
|
})
|
|
.toEqual([])
|
|
})
|
|
|
|
await test.step('the updated app boots to chat, a turn completes, and it reports itself current', async () => {
|
|
const { app, page, logTail } = await launchInstalledApp(facts, env)
|
|
|
|
try {
|
|
const ws = recordWebSockets(page)
|
|
await waitForInteractive(app, page).catch(error => {
|
|
throw new Error(`${(error as Error).message}\n${explain(logTail())}`)
|
|
})
|
|
provider.script(U(1), [{ text: [`${A(1)} `, 'after ', 'update'] }])
|
|
await send(page, `${U(1)} hello after the update`, 'Enter', ws)
|
|
await expect(page.getByText(`${A(1)} after update`)).toBeVisible({ timeout: 120_000 })
|
|
expect(await currentAs(page), `the updated app is current (was ${before})`).toEqual({
|
|
currentSha: target,
|
|
updateAvailable: false
|
|
})
|
|
} finally {
|
|
await closeQuietly(app)
|
|
}
|
|
})
|
|
|
|
expect(fs.existsSync(facts.checkout)).toBe(true)
|
|
} finally {
|
|
await session.close()
|
|
}
|
|
})
|