mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-10-26 00:29:38 +00:00
4af19b73c7
Claude calls never used the LiteLLM above-threshold rates, so Haiku 5.5 requests over 100k prompt tokens (input + cache read + cache write) billed at the base rate. claude joins TIERED_PRICING_PROVIDERS and the transcript paths pass the provider. Long-prompt test fixtures move to Sonnet 4.6, which has no tier, so their round figures hold.
240 lines
8.9 KiB
TypeScript
240 lines
8.9 KiB
TypeScript
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { spawnSync } from 'node:child_process'
|
|
|
|
import { describe, expect, it } from 'vitest'
|
|
|
|
import { getDateRange } from '../src/cli-date.js'
|
|
import { noonTz } from './fixtures/clock.js'
|
|
|
|
const CLI_TIMEOUT_MS = 30_000
|
|
const CLI_TZ = noonTz()
|
|
|
|
function runCli(args: string[], home: string) {
|
|
return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], {
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
CLAUDE_CONFIG_DIR: join(home, '.claude'),
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
HOMEPATH: home,
|
|
HOMEDRIVE: '',
|
|
TZ: CLI_TZ,
|
|
},
|
|
encoding: 'utf-8',
|
|
timeout: CLI_TIMEOUT_MS,
|
|
})
|
|
}
|
|
|
|
async function readConfig(home: string): Promise<{ budget?: { daily?: number; weekly?: number; monthly?: number } }> {
|
|
const raw = await readFile(join(home, '.config', 'codeburn', 'config.json'), 'utf-8')
|
|
return JSON.parse(raw) as { budget?: { daily?: number; weekly?: number; monthly?: number } }
|
|
}
|
|
|
|
function timestampFromDate(date: Date, offsetMinutes = 0): string {
|
|
return new Date(date.getTime() + offsetMinutes * 60_000)
|
|
.toISOString()
|
|
.replace(/\.\d+Z$/, 'Z')
|
|
}
|
|
|
|
function currentMonthTimestamp(offsetMinutes: number): string {
|
|
// Five minutes back. The child runs in CLI_TZ, where it is about noon on the
|
|
// UTC date, so that is this month even on the 1st just after midnight UTC.
|
|
return timestampFromDate(new Date(Date.now() - 5 * 60_000), offsetMinutes)
|
|
}
|
|
|
|
function userLine(sessionId: string, timestamp: string): string {
|
|
return JSON.stringify({
|
|
type: 'user',
|
|
sessionId,
|
|
timestamp,
|
|
cwd: '/tmp/codeburn-budget-app',
|
|
message: { role: 'user', content: 'ship budget check' },
|
|
})
|
|
}
|
|
|
|
function assistantLine(sessionId: string, timestamp: string): string {
|
|
return JSON.stringify({
|
|
type: 'assistant',
|
|
sessionId,
|
|
timestamp,
|
|
cwd: '/tmp/codeburn-budget-app',
|
|
message: {
|
|
id: `msg-${sessionId}`,
|
|
type: 'message',
|
|
role: 'assistant',
|
|
model: 'claude-sonnet-4-6',
|
|
content: [{ type: 'text', text: 'done' }],
|
|
usage: {
|
|
input_tokens: 1_000_000,
|
|
output_tokens: 100_000,
|
|
cache_creation_input_tokens: 0,
|
|
cache_read_input_tokens: 0,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
async function seedClaudeSpend(home: string, opts: { sessionId: string; timestamp: string }): Promise<void> {
|
|
const projectDir = join(home, '.claude', 'projects', 'budget-app')
|
|
await mkdir(projectDir, { recursive: true })
|
|
await writeFile(
|
|
join(projectDir, `${opts.sessionId}.jsonl`),
|
|
[
|
|
userLine(opts.sessionId, opts.timestamp),
|
|
assistantLine(opts.sessionId, timestampFromDate(new Date(opts.timestamp), 1)),
|
|
].join('\n') + '\n',
|
|
'utf-8',
|
|
)
|
|
}
|
|
|
|
async function seedCurrentMonthSpend(home: string): Promise<void> {
|
|
await seedClaudeSpend(home, { sessionId: 'budget-session', timestamp: currentMonthTimestamp(0) })
|
|
}
|
|
|
|
describe('codeburn budget command', () => {
|
|
it('saves, lists, and removes a monthly budget', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
const set = runCli(['budget', '--monthly', '123.45'], home)
|
|
expect(set.status, `stderr: ${set.stderr}`).toBe(0)
|
|
expect(set.stdout).toContain('monthly')
|
|
|
|
const saved = await readConfig(home)
|
|
expect(saved.budget?.monthly).toBe(123.45)
|
|
|
|
const list = runCli(['budget', '--list'], home)
|
|
expect(list.status).toBe(0)
|
|
expect(list.stdout).toContain('monthly')
|
|
expect(list.stdout).toContain('$123.45')
|
|
|
|
const remove = runCli(['budget', '--remove', 'monthly'], home)
|
|
expect(remove.status).toBe(0)
|
|
|
|
const after = await readConfig(home)
|
|
expect(after.budget).toBeUndefined()
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('rejects an invalid amount without writing a budget', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
const result = runCli(['budget', '--daily', '0'], home)
|
|
expect(result.status).toBe(1)
|
|
expect(result.stderr).toContain('--daily must be a finite number greater than 0')
|
|
|
|
const list = runCli(['budget', '--list'], home)
|
|
expect(list.status).toBe(0)
|
|
expect(list.stdout).toContain('No budgets configured')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('exits 1 when the current month is over budget', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
await seedCurrentMonthSpend(home)
|
|
expect(runCli(['budget', '--monthly', '0.01'], home).status).toBe(0)
|
|
|
|
const result = runCli(['budget', '--check'], home)
|
|
expect(result.status, `stdout: ${result.stdout}\nstderr: ${result.stderr}`).toBe(1)
|
|
expect(result.stdout).toContain('monthly:')
|
|
expect(result.stdout).toContain('[OVER]')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('floors a 99.x percent budget check without reporting over', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
await seedCurrentMonthSpend(home)
|
|
expect(runCli(['budget', '--monthly', '4.52'], home).status).toBe(0)
|
|
|
|
const result = runCli(['budget', '--check'], home)
|
|
expect(result.status, `stdout: ${result.stdout}\nstderr: ${result.stderr}`).toBe(0)
|
|
expect(result.stdout).toContain('(99%) [WARN]')
|
|
expect(result.stdout).not.toContain('(100%)')
|
|
expect(result.stdout).not.toContain('[OVER]')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('exits 0 when the current month is under budget or no budget is configured', async () => {
|
|
const noneHome = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
const underHome = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
const none = runCli(['budget', '--check'], noneHome)
|
|
expect(none.status).toBe(0)
|
|
expect(none.stdout).toContain('No budgets configured')
|
|
|
|
await seedCurrentMonthSpend(underHome)
|
|
expect(runCli(['budget', '--monthly', '100000'], underHome).status).toBe(0)
|
|
|
|
const under = runCli(['budget', '--check'], underHome)
|
|
expect(under.status, `stdout: ${under.stdout}\nstderr: ${under.stderr}`).toBe(0)
|
|
expect(under.stdout).toContain('monthly:')
|
|
expect(under.stdout).toContain('[OK]')
|
|
} finally {
|
|
await rm(noneHome, { recursive: true, force: true })
|
|
await rm(underHome, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('keeps overview budget lines only on unfiltered overviews', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
await seedCurrentMonthSpend(home)
|
|
expect(runCli(['budget', '--monthly', '100000'], home).status).toBe(0)
|
|
|
|
const unfiltered = runCli(['overview', '-p', 'month', '--no-color'], home)
|
|
expect(unfiltered.status, `stdout: ${unfiltered.stdout}\nstderr: ${unfiltered.stderr}`).toBe(0)
|
|
expect(unfiltered.stdout).toContain('Monthly budget:')
|
|
|
|
for (const filterArgs of [
|
|
['--provider', 'claude'],
|
|
['--project', 'budget-app'],
|
|
['--exclude', 'not-the-budget-app'],
|
|
]) {
|
|
const filtered = runCli(['overview', '-p', 'month', '--no-color', ...filterArgs], home)
|
|
expect(filtered.status, `args: ${filterArgs.join(' ')}\nstdout: ${filtered.stdout}\nstderr: ${filtered.stderr}`).toBe(0)
|
|
expect(filtered.stdout).toContain('Totals')
|
|
expect(filtered.stdout).not.toMatch(/\b(?:Daily|Weekly|Monthly) budget:/)
|
|
}
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
|
|
it('uses the same weekly spend window for budget --check and overview -p week', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-budget-'))
|
|
try {
|
|
process.env.TZ = CLI_TZ
|
|
const weekStart = getDateRange('week').range.start
|
|
await seedClaudeSpend(home, {
|
|
sessionId: 'weekly-boundary-session',
|
|
timestamp: timestampFromDate(weekStart, 1),
|
|
})
|
|
expect(runCli(['budget', '--weekly', '100000'], home).status).toBe(0)
|
|
|
|
const overview = runCli(['overview', '-p', 'week', '--no-color'], home)
|
|
expect(overview.status, `stdout: ${overview.stdout}\nstderr: ${overview.stderr}`).toBe(0)
|
|
const overviewSpent = overview.stdout.match(/Weekly budget: (\$[0-9,]+\.\d{2}) of/)
|
|
expect(overviewSpent?.[1]).toBeDefined()
|
|
expect(overviewSpent?.[1]).not.toBe('$0.00')
|
|
|
|
const check = runCli(['budget', '--check'], home)
|
|
expect(check.status, `stdout: ${check.stdout}\nstderr: ${check.stderr}`).toBe(0)
|
|
const checkSpent = check.stdout.match(/weekly:\s+(\$[0-9,]+\.\d{2}) of/)
|
|
expect(checkSpent?.[1]).toBe(overviewSpent?.[1])
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
}, CLI_TIMEOUT_MS)
|
|
})
|