mesalogo
61590395ef
Persist Electron renderer exit reasons and exit codes through diagnostic writes, reads, and exports so abnormal window exits can be investigated. Keep older records readable and existing log bounds unchanged. Validation: 18 focused tests, typecheck, lint, and diff checks passed. Full test run timed out after 60 seconds with a SettingsPanel test failure. Release note: Diagnostic logs now retain renderer exit reasons and exit codes to help distinguish out-of-memory exits from other window failures.
279 lines
8.9 KiB
TypeScript
279 lines
8.9 KiB
TypeScript
import {
|
|
mkdtemp,
|
|
readFile,
|
|
readdir,
|
|
rm,
|
|
stat,
|
|
writeFile
|
|
} from 'node:fs/promises'
|
|
import { join } from 'node:path'
|
|
import { tmpdir } from 'node:os'
|
|
import { afterEach, describe, expect, it } from 'vitest'
|
|
import {
|
|
DesktopDiagnostics,
|
|
MAXIMUM_PENDING_DESKTOP_DIAGNOSTIC_WRITES,
|
|
normalizeDesktopDiagnosticRecord
|
|
} from './desktop-diagnostics'
|
|
|
|
const temporaryDirectories: string[] = []
|
|
|
|
async function temporaryDirectory(): Promise<string> {
|
|
const directory = await mkdtemp(
|
|
join(tmpdir(), 'goodbuddy-desktop-diagnostics-')
|
|
)
|
|
temporaryDirectories.push(directory)
|
|
return directory
|
|
}
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(
|
|
temporaryDirectories.splice(0).map((directory) =>
|
|
rm(directory, { recursive: true, force: true })
|
|
)
|
|
)
|
|
})
|
|
|
|
describe('DesktopDiagnostics', () => {
|
|
it('preserves renderer exit details on disk and in exports after restart', async () => {
|
|
const directory = await temporaryDirectory()
|
|
const diagnostics = new DesktopDiagnostics(directory)
|
|
await diagnostics.recordFailure({
|
|
component: 'desktop', stage: 'renderer', code: 'desktop.renderer.gone',
|
|
error: new Error('private renderer details'), reason: 'oom', exitCode: -9
|
|
})
|
|
await diagnostics.dispose()
|
|
const persisted = await readFile(join(directory, 'desktop-diagnostics.ndjson'), 'utf8')
|
|
expect(JSON.parse(persisted)).toMatchObject({ reason: 'oom', exitCode: -9 })
|
|
expect(persisted).not.toContain('private renderer details')
|
|
const restarted = new DesktopDiagnostics(directory)
|
|
try {
|
|
expect(JSON.parse((await restarted.exportRecent()).toString('utf8')))
|
|
.toMatchObject({ reason: 'oom', exitCode: -9 })
|
|
} finally {
|
|
await restarted.dispose()
|
|
}
|
|
})
|
|
|
|
it('omits invalid exit details and keeps older records readable', () => {
|
|
const record = {
|
|
timestamp: '2026-09-28T03:19:18.062Z', component: 'desktop',
|
|
stage: 'renderer', code: 'desktop.renderer.gone', errorType: 'Error'
|
|
}
|
|
const normalized = normalizeDesktopDiagnosticRecord(record)
|
|
expect(normalized).toMatchObject({ code: 'desktop.renderer.gone' })
|
|
expect(normalized).not.toHaveProperty('reason')
|
|
expect(normalized).not.toHaveProperty('exitCode')
|
|
expect(normalizeDesktopDiagnosticRecord({
|
|
...record, reason: 'private error content', exitCode: Infinity
|
|
})).toEqual(normalized)
|
|
})
|
|
|
|
it('persists renderer failure codes without storing raw error content', async () => {
|
|
const diagnostics = new DesktopDiagnostics(await temporaryDirectory())
|
|
for (const code of ['desktop.renderer.gone', 'desktop.renderer.load-failed']) {
|
|
await diagnostics.recordFailure({
|
|
component: 'desktop', stage: 'renderer', code,
|
|
error: new Error('private renderer details')
|
|
})
|
|
}
|
|
const records = await diagnostics.readRecent()
|
|
expect(records.map(record => record.code)).toEqual([
|
|
'desktop.renderer.gone', 'desktop.renderer.load-failed'
|
|
])
|
|
expect(records.every(record => record.message === 'Desktop renderer failed')).toBe(true)
|
|
expect(JSON.stringify(records)).not.toContain('private renderer details')
|
|
await diagnostics.dispose()
|
|
})
|
|
it('rotates within fixed file and byte bounds', async () => {
|
|
const directory = await temporaryDirectory()
|
|
let sequence = 0
|
|
const diagnostics = new DesktopDiagnostics(directory, {
|
|
maximumFileBytes: 420,
|
|
maximumFiles: 3,
|
|
now: () => new Date(sequence++ * 1_000)
|
|
})
|
|
|
|
for (let index = 0; index < 12; index += 1) {
|
|
await diagnostics.recordFailure({
|
|
component: 'runtime',
|
|
stage: 'run',
|
|
code: 'runtime.run.failed',
|
|
error: new Error(`failure ${index}`)
|
|
})
|
|
}
|
|
await diagnostics.dispose()
|
|
|
|
const files = await readdir(directory)
|
|
expect(files).toHaveLength(3)
|
|
for (const file of files) {
|
|
expect((await stat(join(directory, file))).size).toBeLessThanOrEqual(
|
|
420
|
|
)
|
|
}
|
|
|
|
const reopened = new DesktopDiagnostics(directory, {
|
|
maximumFileBytes: 420,
|
|
maximumFiles: 3
|
|
})
|
|
const records = await reopened.readRecent()
|
|
expect(records.length).toBeGreaterThan(0)
|
|
expect(records.length).toBeLessThan(12)
|
|
expect(records.at(-1)).toMatchObject({
|
|
component: 'runtime',
|
|
stage: 'run',
|
|
code: 'runtime.run.failed',
|
|
message: 'Runtime request failed'
|
|
})
|
|
await reopened.dispose()
|
|
})
|
|
|
|
it('reads bounded recent records after restart', async () => {
|
|
const directory = await temporaryDirectory()
|
|
const first = new DesktopDiagnostics(directory, {
|
|
maximumRecords: 2
|
|
})
|
|
await first.recordFailure({
|
|
component: 'desktop',
|
|
stage: 'startup',
|
|
code: 'desktop.startup.failed',
|
|
error: new TypeError('first')
|
|
})
|
|
await first.recordFailure({
|
|
component: 'remote-agent',
|
|
stage: 'connect',
|
|
code: 'remote.connection.network',
|
|
error: new Error('second')
|
|
})
|
|
await first.recordFailure({
|
|
component: 'runtime',
|
|
stage: 'status',
|
|
code: 'runtime.operation.failed',
|
|
error: new Error('third')
|
|
})
|
|
await first.dispose()
|
|
|
|
const restarted = new DesktopDiagnostics(directory, {
|
|
maximumRecords: 2
|
|
})
|
|
await expect(restarted.readRecent(100)).resolves.toMatchObject([
|
|
{ code: 'remote.connection.network' },
|
|
{ code: 'runtime.operation.failed' }
|
|
])
|
|
const exported = await restarted.exportRecent()
|
|
expect(exported.toString('utf8').trim().split('\n')).toHaveLength(2)
|
|
await restarted.dispose()
|
|
})
|
|
|
|
it('never persists raw error content or unknown error names', async () => {
|
|
const directory = await temporaryDirectory()
|
|
const diagnostics = new DesktopDiagnostics(directory)
|
|
const secret =
|
|
'Prompt body password=hunter2 API_KEY=abc https://provider.test/path?token=raw-response'
|
|
const error = new Error(secret)
|
|
error.name = `Credential-${secret}`
|
|
|
|
await diagnostics.recordFailure({
|
|
component: 'runtime',
|
|
stage: secret,
|
|
code: secret,
|
|
error
|
|
})
|
|
const exported = await diagnostics.exportRecent()
|
|
await diagnostics.dispose()
|
|
|
|
expect(exported.toString('utf8')).not.toContain(secret)
|
|
expect(exported.toString('utf8')).not.toContain('hunter2')
|
|
expect(exported.toString('utf8')).not.toContain('provider.test')
|
|
expect(JSON.parse(exported.toString('utf8'))).toMatchObject({
|
|
errorType: 'Error',
|
|
stage: 'unknown',
|
|
code: 'diagnostic.failure',
|
|
message: 'Runtime operation failed'
|
|
})
|
|
const persisted = await readFile(
|
|
join(directory, 'desktop-diagnostics.ndjson'),
|
|
'utf8'
|
|
)
|
|
expect(persisted).not.toContain('API_KEY')
|
|
})
|
|
|
|
it('uses one safe normalizer for externally damaged records', async () => {
|
|
const directory = await temporaryDirectory()
|
|
const damaged = {
|
|
timestamp: '2026-08-25T01:02:03+00:00',
|
|
component: 'remote-agent',
|
|
stage: 'disconnect',
|
|
code: 'remote.connection.lost',
|
|
errorType: 'SensitiveProviderError',
|
|
message: 'password=hunter2'
|
|
}
|
|
expect(normalizeDesktopDiagnosticRecord(damaged)).toEqual({
|
|
timestamp: '2026-08-25T01:02:03.000Z',
|
|
component: 'remote-agent',
|
|
stage: 'disconnect',
|
|
code: 'remote.connection.lost',
|
|
errorType: 'Error',
|
|
message: 'Remote connection was lost'
|
|
})
|
|
await writeFile(
|
|
join(directory, 'desktop-diagnostics.ndjson'),
|
|
`${JSON.stringify(damaged)}\n`,
|
|
'utf8'
|
|
)
|
|
|
|
const diagnostics = new DesktopDiagnostics(directory)
|
|
const records = await diagnostics.readRecent()
|
|
await diagnostics.dispose()
|
|
|
|
expect(records).toEqual([
|
|
{
|
|
timestamp: '2026-08-25T01:02:03.000Z',
|
|
component: 'remote-agent',
|
|
stage: 'disconnect',
|
|
code: 'remote.connection.lost',
|
|
errorType: 'Error',
|
|
message: 'Remote connection was lost'
|
|
}
|
|
])
|
|
expect(JSON.stringify(records)).not.toContain('hunter2')
|
|
})
|
|
|
|
it('normalizes errors immediately and bounds pending writes', async () => {
|
|
const directory = await temporaryDirectory()
|
|
const diagnostics = new DesktopDiagnostics(directory)
|
|
let errorNameReads = 0
|
|
const writes = Array.from(
|
|
{
|
|
length:
|
|
MAXIMUM_PENDING_DESKTOP_DIAGNOSTIC_WRITES + 8
|
|
},
|
|
() => {
|
|
const error = new Error('raw provider failure')
|
|
Object.defineProperty(error, 'name', {
|
|
get: () => {
|
|
errorNameReads += 1
|
|
return 'TypeError'
|
|
}
|
|
})
|
|
return diagnostics.recordFailure({
|
|
component: 'runtime',
|
|
stage: 'run',
|
|
code: 'runtime.run.failed',
|
|
error
|
|
})
|
|
}
|
|
)
|
|
|
|
expect(errorNameReads).toBe(writes.length)
|
|
expect(diagnostics.pendingWriteCount).toBe(
|
|
MAXIMUM_PENDING_DESKTOP_DIAGNOSTIC_WRITES
|
|
)
|
|
await Promise.all(writes)
|
|
expect(diagnostics.pendingWriteCount).toBe(0)
|
|
await expect(diagnostics.readRecent()).resolves.toHaveLength(
|
|
MAXIMUM_PENDING_DESKTOP_DIAGNOSTIC_WRITES
|
|
)
|
|
await diagnostics.dispose()
|
|
})
|
|
})
|