mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-08-01 12:25:31 +00:00
619 lines
34 KiB
TypeScript
619 lines
34 KiB
TypeScript
// @vitest-environment node
|
|
import { mkdtempSync, rmSync } from 'node:fs'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { describe, it, expect, vi } from 'vitest'
|
|
|
|
// Stub electron so importing main.ts does not require an Electron runtime.
|
|
vi.mock('electron', () => ({
|
|
app: { name: 'CodeBurn', whenReady: () => Promise.resolve(), on: () => {}, quit: () => {} },
|
|
BrowserWindow: class {},
|
|
dialog: { showOpenDialog: vi.fn() },
|
|
ipcMain: { handle: () => {} },
|
|
Menu: { buildFromTemplate: (template: unknown) => template, setApplicationMenu: () => {} },
|
|
shell: { openExternal: vi.fn() },
|
|
}))
|
|
|
|
import { createApplicationMenuTemplate, createBeforeQuitHandler, createBridgeHandlers } from './main'
|
|
import { CliError } from './cli'
|
|
import { Telemetry } from './telemetry'
|
|
|
|
function fakeSpawn(result: unknown = { current: { cost: 12.34 } }) {
|
|
const calls: string[][] = []
|
|
const spawnCli = vi.fn(async (args: string[]) => {
|
|
calls.push(args)
|
|
return result
|
|
})
|
|
const spawnCliAction = vi.fn(async (args: string[]) => {
|
|
calls.push(args)
|
|
return { ok: true, stdout: 'updated', stderr: '', code: 0 }
|
|
})
|
|
return { spawnCli, spawnCliAction, calls }
|
|
}
|
|
|
|
// Every codeburn:* channel with a representative arg tuple → the exact argv it
|
|
// must spawn. cliStatus is the one channel that resolves without spawning.
|
|
const CHANNELS = [
|
|
'codeburn:getOverview',
|
|
'codeburn:getQuota',
|
|
'codeburn:getPlans',
|
|
'codeburn:getActReport',
|
|
'codeburn:getModels',
|
|
'codeburn:getSessions',
|
|
'codeburn:getCompareModels',
|
|
'codeburn:getCompare',
|
|
'codeburn:getYield',
|
|
'codeburn:getSpendFlow',
|
|
'codeburn:getOptimizeReport',
|
|
'codeburn:getDevices',
|
|
'codeburn:getDevicesScan',
|
|
'codeburn:getShareStatus',
|
|
'codeburn:getIdentity',
|
|
'codeburn:getAliases',
|
|
'codeburn:getProxyPaths',
|
|
'codeburn:getAudit',
|
|
'codeburn:getPriceOverrides',
|
|
'codeburn:setCurrency',
|
|
'codeburn:resetCurrency',
|
|
'codeburn:addAlias',
|
|
'codeburn:removeAlias',
|
|
'codeburn:setPriceOverride',
|
|
'codeburn:removePriceOverride',
|
|
'codeburn:removeDevice',
|
|
'codeburn:setPlan',
|
|
'codeburn:resetPlan',
|
|
'codeburn:exportData',
|
|
'codeburn:cliStatus',
|
|
'codeburn:telemetryStatus',
|
|
'codeburn:telemetrySetEnabled',
|
|
'codeburn:telemetryOnboarded',
|
|
'codeburn:telemetryTrack',
|
|
'codeburn:getUpdateStatus',
|
|
] as const
|
|
|
|
const ARGV_CASES: Array<{ channel: string; args: unknown[]; argv: string[] }> = [
|
|
{ channel: 'codeburn:getOverview', args: ['30days', 'claude'], argv: ['status', '--format', 'menubar-json', '--period', '30days', '--no-timeline', '--provider', 'claude'] },
|
|
{ channel: 'codeburn:getOverview', args: ['30days', 'all'], argv: ['status', '--format', 'menubar-json', '--period', '30days', '--no-timeline'] },
|
|
{ channel: 'codeburn:getPlans', args: ['week'], argv: ['status', '--format', 'json', '--period', 'week'] },
|
|
{ channel: 'codeburn:getActReport', args: [], argv: ['act', 'report', '--json'] },
|
|
{ channel: 'codeburn:getModels', args: ['week', 'claude', true], argv: ['models', '--format', 'json', '--period', 'week', '--provider', 'claude', '--by-task'] },
|
|
{ channel: 'codeburn:getModels', args: ['week', 'all', false], argv: ['models', '--format', 'json', '--period', 'week'] },
|
|
{ channel: 'codeburn:getSessions', args: ['week', 'all'], argv: ['sessions', '--format', 'json', '--period', 'week'] },
|
|
{ channel: 'codeburn:getSessions', args: ['30days', 'claude', { from: '2026-07-01', to: '2026-07-11' }], argv: ['sessions', '--format', 'json', '--period', '30days', '--provider', 'claude', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getCompareModels', args: ['month', 'codex'], argv: ['compare', '--format', 'json', '--period', 'month', '--provider', 'codex'] },
|
|
{ channel: 'codeburn:getCompare', args: ['month', 'all', 'model-a', 'model-b'], argv: ['compare', '--format', 'json', '--period', 'month', '--model-a', 'model-a', '--model-b', 'model-b'] },
|
|
{ channel: 'codeburn:getYield', args: ['today', 'all'], argv: ['yield', '--format', 'json', '--period', 'today'] },
|
|
{ channel: 'codeburn:getYield', args: ['today', 'claude'], argv: ['yield', '--format', 'json', '--period', 'today', '--provider', 'claude'] },
|
|
{ channel: 'codeburn:getSpendFlow', args: ['month', 'openai'], argv: ['spend', '--format', 'flow-json', '--period', 'month', '--provider', 'openai'] },
|
|
{ channel: 'codeburn:getOptimizeReport', args: ['month', 'openai'], argv: ['optimize', '--format', 'json', '--period', 'month', '--provider', 'openai'] },
|
|
{ channel: 'codeburn:getOverview', args: ['30days', 'all', { from: '2026-07-01', to: '2026-07-11' }], argv: ['status', '--format', 'menubar-json', '--period', '30days', '--no-timeline', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getOverview', args: ['30days', 'all', undefined, 'claude-config:91dda17e8cf35193'], argv: ['status', '--format', 'menubar-json', '--period', '30days', '--no-timeline', '--claude-config-source', 'claude-config:91dda17e8cf35193'] },
|
|
{ channel: 'codeburn:getOverview', args: ['month', 'claude', { from: '2026-07-01', to: '2026-07-11' }, 'claude-desktop:980e1e488a654830'], argv: ['status', '--format', 'menubar-json', '--period', 'month', '--no-timeline', '--provider', 'claude', '--from', '2026-07-01', '--to', '2026-07-11', '--claude-config-source', 'claude-desktop:980e1e488a654830'] },
|
|
{ channel: 'codeburn:getModels', args: ['week', 'claude', true, { from: '2026-07-01', to: '2026-07-11' }], argv: ['models', '--format', 'json', '--period', 'week', '--provider', 'claude', '--by-task', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getYield', args: ['today', 'all', { from: '2026-07-01', to: '2026-07-11' }], argv: ['yield', '--format', 'json', '--period', 'today', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getSpendFlow', args: ['month', 'all', { from: '2026-07-01', to: '2026-07-11' }], argv: ['spend', '--format', 'flow-json', '--period', 'month', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getOptimizeReport', args: ['month', 'all', { from: '2026-07-01', to: '2026-07-11' }], argv: ['optimize', '--format', 'json', '--period', 'month', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getDevices', args: ['week'], argv: ['devices', '--format', 'json', '--period', 'week'] },
|
|
{ channel: 'codeburn:getDevicesScan', args: [], argv: ['devices', 'scan', '--format', 'json'] },
|
|
{ channel: 'codeburn:getShareStatus', args: [], argv: ['share', 'status', '--format', 'json'] },
|
|
{ channel: 'codeburn:getIdentity', args: [], argv: ['identity', '--format', 'json'] },
|
|
{ channel: 'codeburn:getAliases', args: [], argv: ['model-alias', '--list', '--format', 'json'] },
|
|
{ channel: 'codeburn:getProxyPaths', args: [], argv: ['proxy-path', '--list', '--format', 'json'] },
|
|
{ channel: 'codeburn:getAudit', args: ['month', 'claude'], argv: ['audit', '--format', 'json', '--period', 'month', '--provider', 'claude'] },
|
|
{ channel: 'codeburn:getAudit', args: ['30days', 'all', { from: '2026-07-01', to: '2026-07-11' }], argv: ['audit', '--format', 'json', '--period', '30days', '--from', '2026-07-01', '--to', '2026-07-11'] },
|
|
{ channel: 'codeburn:getPriceOverrides', args: [], argv: ['price-override', '--list', '--format', 'json'] },
|
|
{ channel: 'codeburn:setPriceOverride', args: ['unpriced/test-model', { input: 0.27, output: 1.1 }], argv: ['price-override', 'unpriced/test-model', '--input', '0.27', '--output', '1.1'] },
|
|
{ channel: 'codeburn:setPriceOverride', args: ['unpriced/test-model', { input: 0.27, output: 1.1, cacheRead: 0.03, cacheCreation: 0.42 }], argv: ['price-override', 'unpriced/test-model', '--input', '0.27', '--output', '1.1', '--cache-read', '0.03', '--cache-creation', '0.42'] },
|
|
{ channel: 'codeburn:removePriceOverride', args: ['unpriced/test-model'], argv: ['price-override', '--remove', 'unpriced/test-model'] },
|
|
{ channel: 'codeburn:setCurrency', args: ['EUR'], argv: ['currency', 'EUR'] },
|
|
{ channel: 'codeburn:resetCurrency', args: [], argv: ['currency', '--reset'] },
|
|
{ channel: 'codeburn:addAlias', args: ['unknown-model', 'priced-model'], argv: ['model-alias', 'unknown-model', 'priced-model'] },
|
|
{ channel: 'codeburn:removeAlias', args: ['unknown-model'], argv: ['model-alias', '--remove', 'unknown-model'] },
|
|
{ channel: 'codeburn:removeDevice', args: ['studio-mac'], argv: ['devices', 'rm', 'studio-mac'] },
|
|
{ channel: 'codeburn:setPlan', args: ['claude-max', 'claude'], argv: ['plan', 'set', 'claude-max', '--provider', 'claude'] },
|
|
{ channel: 'codeburn:resetPlan', args: ['cursor'], argv: ['plan', 'reset', '--provider', 'cursor'] },
|
|
{ channel: 'codeburn:exportData', args: ['json', 'all', '/tmp/codeburn-export'], argv: ['export', '-f', 'json', '-o', '/tmp/codeburn-export', '--provider', 'all'] },
|
|
]
|
|
|
|
function flattenMenuItems(items: any[]): any[] {
|
|
return items.flatMap(item => {
|
|
const submenu = Array.isArray(item.submenu) ? flattenMenuItems(item.submenu) : []
|
|
return [item, ...submenu]
|
|
})
|
|
}
|
|
|
|
describe('createBridgeHandlers (channel → argv for all channels)', () => {
|
|
const deps = (extra = {}) => ({ spawnCli: vi.fn(), spawnCliAction: vi.fn(), resolveCodeburnPath: () => null, getQuota: vi.fn(async () => []), ...extra })
|
|
it('exposes exactly the bridge channels', () => {
|
|
const handlers = createBridgeHandlers(deps())
|
|
expect(Object.keys(handlers).sort()).toEqual([...CHANNELS].sort())
|
|
})
|
|
|
|
it.each(ARGV_CASES)('$channel with $args spawns the expected argv', async ({ channel, args, argv }) => {
|
|
const { spawnCli, spawnCliAction, calls } = fakeSpawn()
|
|
const handlers = createBridgeHandlers(deps({ spawnCli, spawnCliAction, resolveCodeburnPath: () => '/bin/codeburn' }))
|
|
const res = await handlers[channel]!(...args)
|
|
expect(calls[0]).toEqual(argv)
|
|
expect(res).toMatchObject({ ok: true })
|
|
})
|
|
|
|
it('codeburn:cliStatus resolves from resolveCodeburnPath without spawning', async () => {
|
|
const spawnCli = vi.fn()
|
|
const handlers = createBridgeHandlers(deps({ spawnCli, resolveCodeburnPath: () => '/opt/homebrew/bin/codeburn' }))
|
|
const res = await handlers['codeburn:cliStatus']!()
|
|
expect(spawnCli).not.toHaveBeenCalled()
|
|
expect(res).toEqual({ ok: true, value: { found: true, path: '/opt/homebrew/bin/codeburn' } })
|
|
})
|
|
})
|
|
|
|
describe('createBridgeHandlers (IPC wiring)', () => {
|
|
const withQuota = <T extends object>(value: T) => ({ ...value, getQuota: vi.fn(async () => []) })
|
|
it('returns normalized quota through its own IPC channel and sanitizes unexpected failures', async () => {
|
|
const base = { spawnCli: vi.fn(), spawnCliAction: vi.fn(), resolveCodeburnPath: () => null }
|
|
const value = [{ provider: 'claude' as const, connection: 'connected' as const, primary: null, details: [], planLabel: 'Pro', footerLines: [] }]
|
|
const ok = createBridgeHandlers({ ...base, getQuota: vi.fn(async () => value) })
|
|
expect(await ok['codeburn:getQuota']!()).toEqual({ ok: true, value })
|
|
|
|
const failed = createBridgeHandlers({ ...base, getQuota: vi.fn(async () => { throw new Error('Bearer secret sk-ant-leak') }) })
|
|
const result = await failed['codeburn:getQuota']!()
|
|
expect(result).toMatchObject({ ok: false, error: { kind: 'nonzero' } })
|
|
expect(JSON.stringify(result)).not.toMatch(/secret|sk-ant-leak/)
|
|
})
|
|
it('getOverview spawns menubar-json for the period, omitting --provider for "all"', async () => {
|
|
const { spawnCli, spawnCliAction, calls } = fakeSpawn()
|
|
const handlers = createBridgeHandlers(withQuota({ spawnCli, spawnCliAction, resolveCodeburnPath: () => '/bin/codeburn' }))
|
|
const res = await handlers['codeburn:getOverview']!('30days', 'all')
|
|
expect(calls[0]).toEqual(['status', '--format', 'menubar-json', '--period', '30days', '--no-timeline'])
|
|
expect(res).toEqual({ ok: true, value: { current: { cost: 12.34 } } })
|
|
})
|
|
|
|
it('adds --provider and --by-task when requested', async () => {
|
|
const { spawnCli, spawnCliAction, calls } = fakeSpawn([])
|
|
const handlers = createBridgeHandlers(withQuota({ spawnCli, spawnCliAction, resolveCodeburnPath: () => null }))
|
|
await handlers['codeburn:getModels']!('week', 'claude', true)
|
|
expect(calls[0]).toEqual(['models', '--format', 'json', '--period', 'week', '--provider', 'claude', '--by-task'])
|
|
})
|
|
|
|
it('returns an error envelope carrying the CliError kind', async () => {
|
|
const spawnCli = vi.fn(async () => {
|
|
throw new CliError('nonzero', 'boom')
|
|
})
|
|
const handlers = createBridgeHandlers(withQuota({ spawnCli, spawnCliAction: vi.fn(), resolveCodeburnPath: () => '/bin/codeburn' }))
|
|
const res = await handlers['codeburn:getYield']!('today', 'all')
|
|
expect(res).toEqual({ ok: false, error: { kind: 'nonzero', message: 'boom' } })
|
|
})
|
|
|
|
it('cliStatus reports the resolved binary path', async () => {
|
|
const handlers = createBridgeHandlers(withQuota({
|
|
spawnCli: vi.fn(),
|
|
spawnCliAction: vi.fn(),
|
|
resolveCodeburnPath: () => '/opt/homebrew/bin/codeburn',
|
|
}))
|
|
const res = await handlers['codeburn:cliStatus']!()
|
|
expect(res).toEqual({ ok: true, value: { found: true, path: '/opt/homebrew/bin/codeburn' } })
|
|
})
|
|
})
|
|
|
|
describe('createBridgeHandlers (IPC input validation)', () => {
|
|
const withQuota = <T extends object>(value: T) => ({ ...value, getQuota: vi.fn(async () => []) })
|
|
const REJECTIONS: Array<{ name: string; channel: string; args: unknown[] }> = [
|
|
{ name: 'unknown period', channel: 'codeburn:getOverview', args: ['yesterday', 'all'] },
|
|
{ name: 'provider with shell metacharacters', channel: 'codeburn:getOverview', args: ['30days', 'claude; rm -rf'] },
|
|
{ name: 'uppercase provider', channel: 'codeburn:getModels', args: ['week', 'Claude', false] },
|
|
{ name: 'malformed date range', channel: 'codeburn:getYield', args: ['today', 'all', { from: '2026/07/01', to: '2026-07-11' }] },
|
|
{ name: 'lowercase currency code', channel: 'codeburn:setCurrency', args: ['eur'] },
|
|
{ name: 'alias token that looks like a flag', channel: 'codeburn:addAlias', args: ['--evil', 'safe'] },
|
|
{ name: 'device name that looks like a flag', channel: 'codeburn:removeDevice', args: ['-rf'] },
|
|
{ name: 'relative export path', channel: 'codeburn:exportData', args: ['json', 'all', 'relative/out'] },
|
|
{ name: 'compare model that looks like a flag', channel: 'codeburn:getCompare', args: ['month', 'all', '-a', 'model-b'] },
|
|
{ name: 'price override model that looks like a flag', channel: 'codeburn:setPriceOverride', args: ['-x', { input: 1, output: 2 }] },
|
|
{ name: 'non-positive price override rate', channel: 'codeburn:setPriceOverride', args: ['my-model', { input: 0, output: 2 }] },
|
|
{ name: 'non-finite price override rate', channel: 'codeburn:setPriceOverride', args: ['my-model', { input: 1, output: Number.POSITIVE_INFINITY }] },
|
|
{ name: 'remove price override model that looks like a flag', channel: 'codeburn:removePriceOverride', args: ['--all'] },
|
|
{ name: 'claude config source that looks like a flag', channel: 'codeburn:getOverview', args: ['30days', 'all', undefined, '-rf'] },
|
|
{ name: 'claude config source with shell metacharacters', channel: 'codeburn:getOverview', args: ['30days', 'all', undefined, 'id; rm -rf'] },
|
|
]
|
|
|
|
it.each(REJECTIONS)('rejects $name with a bad-args envelope and never spawns', async ({ channel, args }) => {
|
|
const { spawnCli, spawnCliAction } = fakeSpawn()
|
|
const handlers = createBridgeHandlers(withQuota({ spawnCli, spawnCliAction, resolveCodeburnPath: () => '/bin/codeburn' }))
|
|
const res = await handlers[channel]!(...args)
|
|
expect(res).toMatchObject({ ok: false, error: { kind: 'bad-args' } })
|
|
expect(spawnCli).not.toHaveBeenCalled()
|
|
expect(spawnCliAction).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('still accepts the valid values those cases mutate', async () => {
|
|
const { spawnCli, spawnCliAction, calls } = fakeSpawn()
|
|
const handlers = createBridgeHandlers(withQuota({ spawnCli, spawnCliAction, resolveCodeburnPath: () => '/bin/codeburn' }))
|
|
await handlers['codeburn:exportData']!('json', 'all', '/tmp/out')
|
|
expect(calls[0]).toEqual(['export', '-f', 'json', '-o', '/tmp/out', '--provider', 'all'])
|
|
})
|
|
})
|
|
|
|
describe('createBridgeHandlers (quota force + redaction)', () => {
|
|
it('threads the renderer force flag into getQuota', async () => {
|
|
const base = { spawnCli: vi.fn(), spawnCliAction: vi.fn(), resolveCodeburnPath: () => null }
|
|
const getQuota = vi.fn(async () => [])
|
|
const handlers = createBridgeHandlers({ ...base, getQuota })
|
|
await handlers['codeburn:getQuota']!(true)
|
|
expect(getQuota).toHaveBeenLastCalledWith({ force: true })
|
|
await handlers['codeburn:getQuota']!()
|
|
expect(getQuota).toHaveBeenLastCalledWith({ force: false })
|
|
})
|
|
|
|
it('redacts secrets in ActionResult.stderr before it crosses IPC', async () => {
|
|
const spawnCliAction = vi.fn(async () => ({ ok: false, stdout: '', stderr: 'auth failed: Bearer sk-ant-leak12345', code: 1 }))
|
|
const handlers = createBridgeHandlers({ spawnCli: vi.fn(), spawnCliAction, resolveCodeburnPath: () => '/bin/codeburn', getQuota: vi.fn(async () => []) })
|
|
const res = await handlers['codeburn:setCurrency']!('EUR') as { ok: true; value: { stderr: string } }
|
|
expect(res.ok).toBe(true)
|
|
expect(res.value.stderr).not.toMatch(/sk-ant-leak|Bearer sk-ant/)
|
|
expect(res.value.stderr).toContain('[REDACTED]')
|
|
})
|
|
})
|
|
|
|
describe('createApplicationMenuTemplate', () => {
|
|
it('keeps normal app roles while leaving CmdOrCtrl+R for renderer refresh', () => {
|
|
const items = flattenMenuItems(createApplicationMenuTemplate(false))
|
|
const roles = items.map(item => item.role).filter(Boolean)
|
|
const accelerators = items.map(item => item.accelerator).filter(Boolean)
|
|
|
|
expect(roles).toContain('copy')
|
|
expect(roles).toContain('paste')
|
|
expect(roles).toContain('quit')
|
|
expect(roles).toContain('minimize')
|
|
expect(roles).toContain('close')
|
|
expect(roles).not.toContain('reload')
|
|
expect(roles).not.toContain('forceReload')
|
|
expect(accelerators).not.toContain('CmdOrCtrl+R')
|
|
expect(accelerators).not.toContain('CommandOrControl+R')
|
|
})
|
|
|
|
it('keeps DevTools available in dev without adding reload menu items', () => {
|
|
const roles = flattenMenuItems(createApplicationMenuTemplate(true)).map(item => item.role).filter(Boolean)
|
|
|
|
expect(roles).toContain('toggleDevTools')
|
|
expect(roles).not.toContain('reload')
|
|
expect(roles).not.toContain('forceReload')
|
|
})
|
|
})
|
|
|
|
describe('createBeforeQuitHandler', () => {
|
|
it('flushes app_close to a fast endpoint before allowing quit', async () => {
|
|
const stateDir = mkdtempSync(join(tmpdir(), 'cb-main-quit-'))
|
|
try {
|
|
const posts: Array<{ events: Array<{ name: string }> }> = []
|
|
const fetchFn = vi.fn(async (_url: unknown, init?: { body?: unknown }) => {
|
|
posts.push(JSON.parse(String(init?.body)) as { events: Array<{ name: string }> })
|
|
return { ok: true } as Response
|
|
}) as unknown as typeof fetch
|
|
const telemetry = new Telemetry({ stateDir, country: 'US', isPackaged: true, appVersion: '1', fetchFn })
|
|
telemetry.completeOnboarding(true)
|
|
await telemetry.flush() // isolate the final beat from the onboarding app_open
|
|
posts.length = 0
|
|
|
|
const quit = vi.fn()
|
|
const killChildren = vi.fn()
|
|
const handler = createBeforeQuitHandler({ getTelemetry: () => telemetry, killAll: killChildren, quit })
|
|
const firstEvent = { preventDefault: vi.fn() }
|
|
handler(firstEvent)
|
|
|
|
expect(firstEvent.preventDefault).toHaveBeenCalledOnce()
|
|
await vi.waitFor(() => expect(quit).toHaveBeenCalledOnce())
|
|
expect(killChildren).toHaveBeenCalledOnce()
|
|
expect(posts).toHaveLength(1)
|
|
expect(posts[0]!.events.map(event => event.name)).toContain('app_close')
|
|
|
|
const finalEvent = { preventDefault: vi.fn() }
|
|
handler(finalEvent)
|
|
expect(finalEvent.preventDefault).not.toHaveBeenCalled()
|
|
expect(quit).toHaveBeenCalledOnce()
|
|
} finally {
|
|
rmSync(stateDir, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('allows quit at 1500ms when the endpoint never resolves and does not re-enter', async () => {
|
|
vi.useFakeTimers()
|
|
try {
|
|
const trackClose = vi.fn()
|
|
const flush = vi.fn(() => new Promise<boolean>(() => {}))
|
|
const quit = vi.fn()
|
|
const handler = createBeforeQuitHandler({
|
|
getTelemetry: () => ({ trackClose, flush }),
|
|
killAll: vi.fn(),
|
|
quit,
|
|
})
|
|
|
|
const firstEvent = { preventDefault: vi.fn() }
|
|
handler(firstEvent)
|
|
const repeatedEvent = { preventDefault: vi.fn() }
|
|
handler(repeatedEvent)
|
|
|
|
expect(firstEvent.preventDefault).toHaveBeenCalledOnce()
|
|
expect(repeatedEvent.preventDefault).toHaveBeenCalledOnce()
|
|
expect(trackClose).toHaveBeenCalledOnce()
|
|
expect(flush).toHaveBeenCalledOnce()
|
|
|
|
await vi.advanceTimersByTimeAsync(1499)
|
|
expect(quit).not.toHaveBeenCalled()
|
|
await vi.advanceTimersByTimeAsync(1)
|
|
expect(quit).toHaveBeenCalledOnce()
|
|
|
|
const finalEvent = { preventDefault: vi.fn() }
|
|
handler(finalEvent)
|
|
expect(finalEvent.preventDefault).not.toHaveBeenCalled()
|
|
expect(quit).toHaveBeenCalledOnce()
|
|
} finally {
|
|
vi.useRealTimers()
|
|
}
|
|
})
|
|
|
|
it('still flushes and quits when trackClose throws synchronously', async () => {
|
|
const trackClose = vi.fn(() => { throw new Error('track close failed') })
|
|
const flush = vi.fn(async () => true)
|
|
const quit = vi.fn()
|
|
const handler = createBeforeQuitHandler({
|
|
getTelemetry: () => ({ trackClose, flush }),
|
|
killAll: vi.fn(),
|
|
quit,
|
|
})
|
|
|
|
handler({ preventDefault: vi.fn() })
|
|
|
|
await vi.waitFor(() => expect(quit).toHaveBeenCalledOnce())
|
|
expect(trackClose).toHaveBeenCalledOnce()
|
|
expect(flush).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('still quits when synchronous child cleanup throws', async () => {
|
|
const quit = vi.fn()
|
|
const handler = createBeforeQuitHandler({
|
|
getTelemetry: () => null,
|
|
killAll: () => { throw new Error('child cleanup failed') },
|
|
quit,
|
|
})
|
|
|
|
handler({ preventDefault: vi.fn() })
|
|
|
|
await vi.waitFor(() => expect(quit).toHaveBeenCalledOnce())
|
|
})
|
|
|
|
it('still quits when synchronous telemetry lookup throws', async () => {
|
|
const quit = vi.fn()
|
|
const handler = createBeforeQuitHandler({
|
|
getTelemetry: () => { throw new Error('telemetry lookup failed') },
|
|
killAll: vi.fn(),
|
|
quit,
|
|
})
|
|
|
|
handler({ preventDefault: vi.fn() })
|
|
|
|
await vi.waitFor(() => expect(quit).toHaveBeenCalledOnce())
|
|
})
|
|
|
|
it('does not wait for the timeout when telemetry cannot send yet', async () => {
|
|
const stateDir = mkdtempSync(join(tmpdir(), 'cb-main-no-consent-'))
|
|
try {
|
|
const fetchFn = vi.fn() as unknown as typeof fetch
|
|
const telemetry = new Telemetry({ stateDir, country: 'US', isPackaged: true, appVersion: '1', fetchFn })
|
|
const quit = vi.fn()
|
|
const handler = createBeforeQuitHandler({ getTelemetry: () => telemetry, killAll: vi.fn(), quit })
|
|
|
|
handler({ preventDefault: vi.fn() })
|
|
await vi.waitFor(() => expect(quit).toHaveBeenCalledOnce())
|
|
expect(fetchFn).not.toHaveBeenCalled()
|
|
} finally {
|
|
rmSync(stateDir, { recursive: true, force: true })
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('createBridgeHandlers (cold-start warmup)', () => {
|
|
const base = (extra: object) => ({ spawnCli: vi.fn(), spawnCliAction: vi.fn(), resolveCodeburnPath: () => '/bin/codeburn', getQuota: vi.fn(async () => []), ...extra })
|
|
|
|
it('gives the first overview a long timeout + progress env, then reverts once warmed', async () => {
|
|
const opts: Array<Record<string, unknown> | undefined> = []
|
|
const spawnCli = vi.fn(async (_args: string[], o?: Record<string, unknown>) => { opts.push(o); return { current: { cost: 1 } } })
|
|
const emitProgress = vi.fn()
|
|
const handlers = createBridgeHandlers(base({ spawnCli, emitProgress }))
|
|
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
expect(opts[0]?.timeoutMs).toBe(10 * 60_000)
|
|
expect((opts[0]?.extraEnv as Record<string, string> | undefined)?.CODEBURN_PROGRESS).toBe('1')
|
|
expect(typeof opts[0]?.onStderr).toBe('function')
|
|
expect(emitProgress).toHaveBeenCalledWith({ kind: 'done' })
|
|
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
expect(opts[1]?.timeoutMs).toBeUndefined()
|
|
expect(opts[1]?.extraEnv).toBeUndefined()
|
|
})
|
|
|
|
it('drops a warmed overview to background priority only when the prefetch flag is set', async () => {
|
|
const opts: Array<Record<string, unknown> | undefined> = []
|
|
const spawnCli = vi.fn(async (_args: string[], o?: Record<string, unknown>) => { opts.push(o); return { current: { cost: 1 } } })
|
|
const handlers = createBridgeHandlers(base({ spawnCli, emitProgress: vi.fn() }))
|
|
|
|
await handlers['codeburn:getOverview']!('30days', 'all') // cold warmup → interactive
|
|
await handlers['codeburn:getOverview']!('30days', 'claude') // warmed, no flag → interactive
|
|
await handlers['codeburn:getOverview']!('30days', 'grok', undefined, null, true) // prefetch → background
|
|
|
|
expect(opts[0]?.priority).toBeUndefined()
|
|
expect(opts[1]?.priority).toBeUndefined()
|
|
expect(opts[2]?.priority).toBe('background')
|
|
})
|
|
|
|
it('re-arms the long timeout when the first overview fails (cache is still cold)', async () => {
|
|
const opts: Array<{ timeoutMs?: number } | undefined> = []
|
|
let n = 0
|
|
const spawnCli = vi.fn(async (_args: string[], o?: { timeoutMs?: number }) => {
|
|
opts.push(o)
|
|
if (++n === 1) throw new CliError('timeout', 'timed out')
|
|
return { current: { cost: 1 } }
|
|
})
|
|
const handlers = createBridgeHandlers(base({ spawnCli, emitProgress: vi.fn() }))
|
|
|
|
expect(await handlers['codeburn:getOverview']!('30days', 'all')).toMatchObject({ ok: false })
|
|
expect(await handlers['codeburn:getOverview']!('30days', 'all')).toMatchObject({ ok: true })
|
|
expect(opts[0]?.timeoutMs).toBe(10 * 60_000)
|
|
expect(opts[1]?.timeoutMs).toBe(10 * 60_000)
|
|
})
|
|
|
|
it('parses CLI scan-progress stderr lines and forwards them to emitProgress', async () => {
|
|
const spawnCli = vi.fn(async (_args: string[], o?: { onStderr?: (chunk: string) => void }) => {
|
|
// A split line proves the reader buffers across chunks.
|
|
o?.onStderr?.('CODEBURN_PROGRESS {"kind":"providers","providers":["claude","codex"]}\nCODEBURN_PROG')
|
|
o?.onStderr?.('RESS {"kind":"tick","provider":"claude","done":5,"total":10}\nnoise line\n')
|
|
return { current: { cost: 1 } }
|
|
})
|
|
const emitProgress = vi.fn()
|
|
const handlers = createBridgeHandlers(base({ spawnCli, emitProgress }))
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
|
|
expect(emitProgress).toHaveBeenCalledWith({ kind: 'providers', providers: ['claude', 'codex'] })
|
|
expect(emitProgress).toHaveBeenCalledWith({ kind: 'tick', provider: 'claude', done: 5, total: 10 })
|
|
})
|
|
})
|
|
|
|
describe('createBridgeHandlers (telemetry wiring)', () => {
|
|
const fakeTelemetry = () => ({
|
|
status: vi.fn(() => ({ installId: 'id-1', country: 'US', enabled: true, defaultEnabled: true, onboarded: false })),
|
|
setEnabled: vi.fn((enabled: boolean) => ({ installId: 'id-2', country: 'US', enabled, defaultEnabled: true, onboarded: false })),
|
|
completeOnboarding: vi.fn((enabled: boolean) => ({ installId: 'id-1', country: 'US', enabled, defaultEnabled: true, onboarded: true })),
|
|
track: vi.fn(),
|
|
})
|
|
const deps = (telemetry: ReturnType<typeof fakeTelemetry> | null) => ({
|
|
spawnCli: vi.fn(async () => ({ current: { cost: 1 } })),
|
|
spawnCliAction: vi.fn(),
|
|
resolveCodeburnPath: () => '/bin/codeburn',
|
|
getQuota: vi.fn(async () => []),
|
|
emitProgress: vi.fn(),
|
|
telemetry,
|
|
})
|
|
|
|
it('exposes status/consent/track channels and forwards to the telemetry service', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const handlers = createBridgeHandlers(deps(telemetry))
|
|
|
|
expect(await handlers['codeburn:telemetryStatus']!()).toMatchObject({ ok: true, value: { installId: 'id-1', onboarded: false } })
|
|
expect(await handlers['codeburn:telemetrySetEnabled']!(false)).toMatchObject({ ok: true, value: { enabled: false } })
|
|
expect(telemetry.setEnabled).toHaveBeenCalledWith(false)
|
|
expect(await handlers['codeburn:telemetryOnboarded']!(true)).toMatchObject({ ok: true, value: { onboarded: true } })
|
|
expect(telemetry.completeOnboarding).toHaveBeenCalledWith(true)
|
|
await handlers['codeburn:telemetryTrack']!('section_view', { section: 'spend' })
|
|
expect(telemetry.track).toHaveBeenCalledWith('section_view', { section: 'spend' })
|
|
})
|
|
|
|
it('returns null (not an error) when telemetry is unavailable', async () => {
|
|
const handlers = createBridgeHandlers(deps(null))
|
|
expect(await handlers['codeburn:telemetryStatus']!()).toEqual({ ok: true, value: null })
|
|
expect(await handlers['codeburn:telemetryTrack']!('section_view', {})).toEqual({ ok: true, value: true })
|
|
})
|
|
|
|
it('tracks cold_start once on the first overview success, with duration', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const handlers = createBridgeHandlers(deps(telemetry))
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
const coldStarts = telemetry.track.mock.calls.filter(([name]) => name === 'cold_start')
|
|
expect(coldStarts.length).toBe(1)
|
|
expect(coldStarts[0]![1]).toMatchObject({ timedOut: false })
|
|
expect(typeof (coldStarts[0]![1] as { ms: number }).ms).toBe('number')
|
|
})
|
|
|
|
it('records cold_start exactly once across coalesced re-polls, with the first-attempt duration (no cumulative ladder)', async () => {
|
|
vi.useFakeTimers()
|
|
vi.setSystemTime(0)
|
|
try {
|
|
const telemetry = fakeTelemetry()
|
|
// Coalescing: every same-arg cold re-poll joins the ONE in-flight child.
|
|
let release!: (v: unknown) => void
|
|
const shared = new Promise(res => { release = res })
|
|
const spawnCli = vi.fn(() => shared)
|
|
const handlers = createBridgeHandlers({ ...deps(telemetry), spawnCli })
|
|
|
|
const p1 = handlers['codeburn:getOverview']!('30days', 'all') // anchors cold clock at t=0
|
|
vi.setSystemTime(30_000)
|
|
const p2 = handlers['codeburn:getOverview']!('30days', 'all')
|
|
vi.setSystemTime(60_000)
|
|
const p3 = handlers['codeburn:getOverview']!('30days', 'all')
|
|
|
|
// The stuck child finally settles ~102.8s after launch.
|
|
vi.setSystemTime(102_801)
|
|
release({ current: { cost: 1 } })
|
|
await Promise.all([p1, p2, p3])
|
|
|
|
const coldStarts = telemetry.track.mock.calls.filter(([name]) => name === 'cold_start')
|
|
expect(coldStarts.length).toBe(1)
|
|
// One row, first-attempt duration — not the old 42801→72800→102801 ladder.
|
|
expect(coldStarts[0]![1]).toMatchObject({ ms: 102_801, timedOut: false })
|
|
} finally {
|
|
vi.useRealTimers()
|
|
}
|
|
})
|
|
|
|
it('records cold_start with timedOut:true when the first (cold) overview attempt times out', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const spawnCli = vi.fn(async () => { throw new CliError('timeout', 'timed out') })
|
|
const handlers = createBridgeHandlers({ ...deps(telemetry), spawnCli })
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
const coldStarts = telemetry.track.mock.calls.filter(([name]) => name === 'cold_start')
|
|
expect(coldStarts.length).toBe(1)
|
|
expect(coldStarts[0]![1]).toMatchObject({ timedOut: true })
|
|
})
|
|
|
|
it('does not re-emit cold_start on a warmup re-arm, keeping the first attempt timedOut:true', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
let n = 0
|
|
const spawnCli = vi.fn(async () => {
|
|
if (++n === 1) throw new CliError('timeout', 'timed out') // first cold attempt: final timeout
|
|
return { current: { cost: 1 } } // re-armed cold attempt succeeds
|
|
})
|
|
const handlers = createBridgeHandlers({ ...deps(telemetry), spawnCli })
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
await handlers['codeburn:getOverview']!('30days', 'all')
|
|
const coldStarts = telemetry.track.mock.calls.filter(([name]) => name === 'cold_start')
|
|
expect(coldStarts.length).toBe(1)
|
|
expect(coldStarts[0]![1]).toMatchObject({ timedOut: true })
|
|
})
|
|
|
|
it('tracks cli_error with the failing kind and the CLI subcommand (cmd = argv[0])', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const failing = {
|
|
...deps(telemetry),
|
|
spawnCli: vi.fn(async () => { throw new CliError('timeout', 'timed out') }),
|
|
}
|
|
const handlers = createBridgeHandlers(failing)
|
|
await handlers['codeburn:getSessions']!('week', 'all')
|
|
expect(telemetry.track).toHaveBeenCalledWith('cli_error', { cmd: 'sessions', kind: 'timeout' })
|
|
})
|
|
|
|
it('includes the resolution-stage detail for a not-found (self-diagnosing without a repro)', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const failing = {
|
|
...deps(telemetry),
|
|
// Mirrors the Windows P0: bundled path present but rejected by the resolver.
|
|
spawnCli: vi.fn(async () => { throw new CliError('not-found', 'codeburn CLI not found', 'bundled-not-absolute') }),
|
|
}
|
|
const handlers = createBridgeHandlers(failing)
|
|
await handlers['codeburn:getPlans']!('week')
|
|
expect(telemetry.track).toHaveBeenCalledWith('cli_error', { cmd: 'status', kind: 'not-found', detail: 'bundled-not-absolute' })
|
|
})
|
|
|
|
it('never leaks a path or message into cli_error telemetry, even when the error carries one', async () => {
|
|
const telemetry = fakeTelemetry()
|
|
const failing = {
|
|
...deps(telemetry),
|
|
// A spawn-time ENOENT whose message embeds a filesystem path.
|
|
spawnCli: vi.fn(async () => {
|
|
throw new CliError('not-found', 'spawn C:\\Users\\alice\\secret\\codeburn.exe ENOENT', 'spawn-error')
|
|
}),
|
|
}
|
|
const handlers = createBridgeHandlers(failing)
|
|
await handlers['codeburn:getSessions']!('week', 'all')
|
|
const props = telemetry.track.mock.calls.find(([name]) => name === 'cli_error')![1] as Record<string, unknown>
|
|
expect(props).toEqual({ cmd: 'sessions', kind: 'not-found', detail: 'spawn-error' })
|
|
expect(JSON.stringify(props)).not.toContain('secret')
|
|
expect(JSON.stringify(props)).not.toContain('C:\\')
|
|
})
|
|
})
|