mesalogo
d80d42b032
Main no longer opens desktop business SQLite. A single utility-process
storage owner holds the Assistant, Knowledge, attachment, document-result,
remote-binding and native model-ledger databases and runs whole domain
transactions; Main and Runtime callers use explicit async domain operations.
- Remove the Main readWithFallback path and the supervision worker's
separate business write connection; manifests are scanned read-only and
committed by the sole writer.
- Remote events are ACKed only after commit; process loss reports
unconfirmed writes instead of replaying them.
- Use native utilityProcess messaging with one in-flight bound (32) and
ordered waiting instead of capacity rejection and retries.
- Start the storage process before the window so startup overlaps.
- Keep short tool output in memory and store full output once in owned
storage; paging, branching, restart and deletion reuse that copy.
- Put required runtime launch files under goodbuddy-prefixed owned temp
directories and reclaim confirmed stale ones; stop writing duplicate
parsed.md.
- Add lint guards for SQLite ownership and architecture, concurrency
acceptance fixtures, and maintenance/architecture documentation.
Validation: typecheck and lint pass. Alternating baseline (edf019aa) vs
candidate runs show no regression on single-session, C01, C02, C04 and a
5-minute C06; Main p99 drops from ~21 ms to ~16.7 ms under concurrency.
Fresh portable copy (1.75M events) upgrade content unchanged; real-model
output paging passes with 4 external requests. Full npm test runs had
1-9 different timing-sensitive failures per run that pass when rerun.
Not covered: C03 review publication, C07 source body, app-level C05.
116 lines
3.6 KiB
TypeScript
116 lines
3.6 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from 'vitest'
|
|
import { readFile } from 'node:fs/promises'
|
|
import { join } from 'node:path'
|
|
import {
|
|
runCleanupBeforeDeadline,
|
|
settleCleanupPhases,
|
|
waitForCleanup
|
|
} from './shutdown'
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers()
|
|
})
|
|
|
|
describe('waitForCleanup', () => {
|
|
it('detaches runtime ownership before ordinary runtime disposal on Desktop exit', async () => {
|
|
const source = await readFile(
|
|
join(process.cwd(), 'src', 'main', 'index.ts'),
|
|
'utf8'
|
|
)
|
|
const cleanup = source.match(
|
|
/const cleanup = settleCleanupPhases\(\[[\s\S]*?\s+globalShortcut/u
|
|
)?.[0] ?? ''
|
|
|
|
expect(cleanup).toContain('runtime?.detachForApplicationExit()')
|
|
expect(cleanup).toContain(
|
|
'selectedRuntimeManager?.detachForApplicationExit()'
|
|
)
|
|
expect(cleanup.indexOf('runtime?.detachForApplicationExit()')).toBeLessThan(
|
|
cleanup.indexOf('runtime?.dispose()')
|
|
)
|
|
const storageClose = cleanup.indexOf('desktopStorage?.close()')
|
|
expect(storageClose).toBeGreaterThan(0)
|
|
for (const drain of [
|
|
'applicationStartup', 'runtimeTemporaryCleanup', 'removeIpcHandlers?.()',
|
|
'startupSubagentService?.dispose()', 'imageGenerationService?.dispose()',
|
|
'nativeClientCoordinator?.dispose()', 'startupContextManager?.dispose()',
|
|
'runtime?.dispose()', 'selectedRuntimeManager?.dispose()',
|
|
'terminalSessionManager?.dispose()', 'managedRemoteExecutionServices?.dispose()',
|
|
'knowledgeGateway?.dispose()', 'knowledgeService?.dispose()',
|
|
'documentParsingService?.dispose()'
|
|
]) {
|
|
expect(cleanup.indexOf(drain), drain).toBeGreaterThanOrEqual(0)
|
|
expect(cleanup.indexOf(drain), drain).toBeLessThan(storageClose)
|
|
}
|
|
expect(source).not.toContain('assistantDatabase?.close()')
|
|
const quitting = source.slice(source.indexOf("app.on('before-quit'"))
|
|
expect(quitting.indexOf('runtimeTemporaryCleanupController.abort()')).toBeLessThan(
|
|
quitting.indexOf('const cleanup = settleCleanupPhases')
|
|
)
|
|
expect(quitting).toContain('clearTimeout(runtimeTemporaryCleanupTimer)')
|
|
})
|
|
|
|
it('reports completed and failed cleanup as settled', async () => {
|
|
await expect(
|
|
waitForCleanup(Promise.resolve(), 100)
|
|
).resolves.toBe(true)
|
|
await expect(
|
|
waitForCleanup(Promise.reject(new Error('cleanup failed')), 100)
|
|
).resolves.toBe(true)
|
|
})
|
|
|
|
it('stops waiting after the shutdown deadline', async () => {
|
|
vi.useFakeTimers()
|
|
const result = waitForCleanup(new Promise(() => {}), 100)
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
await expect(result).resolves.toBe(false)
|
|
})
|
|
|
|
it('runs dependent cleanup phases in order despite failures', async () => {
|
|
const order: string[] = []
|
|
|
|
await settleCleanupPhases([
|
|
[
|
|
async () => {
|
|
order.push('ipc')
|
|
throw new Error('cleanup failed')
|
|
}
|
|
],
|
|
[
|
|
async () => {
|
|
order.push('gateway')
|
|
}
|
|
],
|
|
[
|
|
async () => {
|
|
order.push('knowledge')
|
|
}
|
|
]
|
|
])
|
|
|
|
expect(order).toEqual(['ipc', 'gateway', 'knowledge'])
|
|
})
|
|
|
|
it('finalizes databases only after cleanup beats the deadline', async () => {
|
|
const finalize = vi.fn()
|
|
await expect(
|
|
runCleanupBeforeDeadline(Promise.resolve(), 100, finalize)
|
|
).resolves.toBe(true)
|
|
expect(finalize).toHaveBeenCalledOnce()
|
|
|
|
vi.useFakeTimers()
|
|
const timedOutFinalize = vi.fn()
|
|
const result = runCleanupBeforeDeadline(
|
|
new Promise(() => {}),
|
|
100,
|
|
timedOutFinalize
|
|
)
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
await expect(result).resolves.toBe(false)
|
|
expect(timedOutFinalize).not.toHaveBeenCalled()
|
|
})
|
|
})
|