wehub-resource-sync
644 lines
24 KiB
TypeScript
644 lines
24 KiB
TypeScript
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { delimiter as pathDelimiter, join } from 'node:path'
|
|
import { spawnSync } from 'node:child_process'
|
|
|
|
import { describe, expect, it } from 'vitest'
|
|
|
|
function runCli(args: string[], home: string, extraEnv: Record<string, string | undefined> = {}) {
|
|
return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], {
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
CLAUDE_CONFIG_DIR: join(home, '.claude'),
|
|
CODEBURN_CACHE_DIR: join(home, '.cache', 'codeburn'),
|
|
HOME: home,
|
|
TZ: 'UTC',
|
|
...extraEnv,
|
|
},
|
|
encoding: 'utf-8',
|
|
timeout: 30_000,
|
|
})
|
|
}
|
|
|
|
function userLine(sessionId: string, timestamp: string): string {
|
|
return JSON.stringify({
|
|
type: 'user',
|
|
sessionId,
|
|
timestamp,
|
|
message: { role: 'user', content: 'do the thing' },
|
|
})
|
|
}
|
|
|
|
function assistantLine(sessionId: string, timestamp: string, messageId: string): string {
|
|
return JSON.stringify({
|
|
type: 'assistant',
|
|
sessionId,
|
|
timestamp,
|
|
message: {
|
|
id: messageId,
|
|
type: 'message',
|
|
role: 'assistant',
|
|
model: 'claude-sonnet-4-5',
|
|
content: [
|
|
{ type: 'text', text: 'done' },
|
|
{ type: 'tool_use', id: 'tu-1', name: 'Edit', input: { file_path: '/tmp/x', old_string: 'a', new_string: 'b' } },
|
|
],
|
|
usage: { input_tokens: 500, output_tokens: 50 },
|
|
},
|
|
})
|
|
}
|
|
|
|
describe('codeburn status --format menubar-json', () => {
|
|
it('returns valid MenubarPayload with expected top-level fields', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-'))
|
|
|
|
try {
|
|
const projectDir = join(home, '.claude', 'projects', 'myapp')
|
|
await mkdir(projectDir, { recursive: true })
|
|
|
|
const now = new Date()
|
|
const h = now.getUTCHours()
|
|
const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000)
|
|
const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts3 = new Date(base.getTime() + 120_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts4 = new Date(base.getTime() + 180_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
|
|
await writeFile(
|
|
join(projectDir, 'session.jsonl'),
|
|
[
|
|
userLine('s1', ts1),
|
|
assistantLine('s1', ts2, 'msg-1'),
|
|
userLine('s1', ts3),
|
|
assistantLine('s1', ts4, 'msg-2'),
|
|
].join('\n'),
|
|
)
|
|
|
|
const result = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--period', 'today',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home)
|
|
|
|
expect(result.status, `stderr: ${result.stderr}`).toBe(0)
|
|
|
|
const payload = JSON.parse(result.stdout) as Record<string, unknown>
|
|
|
|
expect(payload).toHaveProperty('generated')
|
|
expect(payload).toHaveProperty('current')
|
|
expect(payload).toHaveProperty('optimize')
|
|
expect(payload).toHaveProperty('history')
|
|
|
|
const current = payload['current'] as Record<string, unknown>
|
|
expect(current['cost']).toBeGreaterThan(0)
|
|
expect(current['calls']).toBe(2)
|
|
expect(current['sessions']).toBe(1)
|
|
expect(current).toHaveProperty('oneShotRate')
|
|
expect(current).toHaveProperty('topActivities')
|
|
expect(current).toHaveProperty('topModels')
|
|
expect(current).toHaveProperty('providers')
|
|
|
|
const history = payload['history'] as { daily: unknown[] }
|
|
expect(Array.isArray(history.daily)).toBe(true)
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('filters menubar payloads to a selected review day with --day', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-day-'))
|
|
|
|
try {
|
|
const projectDir = join(home, '.claude', 'projects', 'myapp')
|
|
await mkdir(projectDir, { recursive: true })
|
|
|
|
await writeFile(
|
|
join(projectDir, 'session.jsonl'),
|
|
[
|
|
userLine('before', '2026-04-09T23:58:00Z'),
|
|
assistantLine('before', '2026-04-09T23:59:00Z', 'msg-before'),
|
|
userLine('selected', '2026-04-10T11:59:00Z'),
|
|
assistantLine('selected', '2026-04-10T12:00:00Z', 'msg-selected'),
|
|
userLine('after', '2026-04-11T00:00:00Z'),
|
|
assistantLine('after', '2026-04-11T00:01:00Z', 'msg-after'),
|
|
].join('\n'),
|
|
)
|
|
|
|
const result = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--day', '2026-04-10',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home)
|
|
|
|
expect(result.status, `stderr: ${result.stderr}`).toBe(0)
|
|
|
|
const payload = JSON.parse(result.stdout) as {
|
|
current: {
|
|
label: string
|
|
calls: number
|
|
sessions: number
|
|
topProjects: Array<{ sessions: number; sessionDetails: Array<{ date: string }> }>
|
|
}
|
|
}
|
|
|
|
expect(payload.current.label).toBe('Day (2026-04-10)')
|
|
expect(payload.current.calls).toBe(1)
|
|
expect(payload.current.sessions).toBe(1)
|
|
expect(payload.current.topProjects).toHaveLength(1)
|
|
expect(payload.current.topProjects[0]?.sessions).toBe(1)
|
|
expect(payload.current.topProjects[0]?.sessionDetails.map(s => s.date)).toEqual(['2026-04-10'])
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('filters the whole menubar payload to a selected Claude config source', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-claude-config-'))
|
|
|
|
try {
|
|
const work = join(home, 'claude-work')
|
|
const personal = join(home, 'claude-personal')
|
|
const slug = 'shared-app'
|
|
await mkdir(join(work, 'projects', slug), { recursive: true })
|
|
await mkdir(join(personal, 'projects', slug), { recursive: true })
|
|
|
|
await writeFile(
|
|
join(work, 'projects', slug, 'work.jsonl'),
|
|
[
|
|
userLine('work', '2026-04-10T11:59:00Z'),
|
|
assistantLine('work', '2026-04-10T12:00:00Z', 'msg-work'),
|
|
].join('\n'),
|
|
)
|
|
await writeFile(
|
|
join(personal, 'projects', slug, 'personal.jsonl'),
|
|
[
|
|
userLine('personal', '2026-04-10T12:59:00Z'),
|
|
assistantLine('personal', '2026-04-10T13:00:00Z', 'msg-personal'),
|
|
].join('\n'),
|
|
)
|
|
|
|
const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) }
|
|
const allResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--period', 'all',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(allResult.status, `stderr: ${allResult.stderr}`).toBe(0)
|
|
const allPayload = JSON.parse(allResult.stdout) as {
|
|
current: { calls: number; sessions: number }
|
|
claudeConfigs?: { selectedId: string | null; options: Array<{ id: string; label: string; path: string }> }
|
|
}
|
|
expect(allPayload.current.calls).toBe(2)
|
|
expect(allPayload.current.sessions).toBe(2)
|
|
expect(allPayload.claudeConfigs?.selectedId).toBeNull()
|
|
expect(allPayload.claudeConfigs?.options.map(o => o.label).sort()).toEqual(['claude-personal', 'claude-work'])
|
|
|
|
const workSourceId = allPayload.claudeConfigs!.options.find(o => o.label === 'claude-work')!.id
|
|
const workResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--period', 'all',
|
|
'--provider', 'all',
|
|
'--claude-config-source', workSourceId,
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(workResult.status, `stderr: ${workResult.stderr}`).toBe(0)
|
|
const workPayload = JSON.parse(workResult.stdout) as {
|
|
current: { calls: number; sessions: number; providers: Record<string, number> }
|
|
history: { daily: Array<{ calls: number }> }
|
|
claudeConfigs?: { selectedId: string | null }
|
|
}
|
|
expect(workPayload.claudeConfigs?.selectedId).toBe(workSourceId)
|
|
expect(workPayload.current.calls).toBe(1)
|
|
expect(workPayload.current.sessions).toBe(1)
|
|
expect(Object.keys(workPayload.current.providers)).toEqual(['claude'])
|
|
expect(workPayload.history.daily.reduce((sum, d) => sum + d.calls, 0)).toBe(1)
|
|
|
|
const invalidResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--period', 'all',
|
|
'--provider', 'all',
|
|
'--claude-config-source', 'claude-config:missing',
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(invalidResult.status, `stderr: ${invalidResult.stderr}`).toBe(0)
|
|
const invalidPayload = JSON.parse(invalidResult.stdout) as {
|
|
current: { calls: number }
|
|
claudeConfigs?: { selectedId: string | null }
|
|
}
|
|
expect(invalidPayload.current.calls).toBe(2)
|
|
expect(invalidPayload.claudeConfigs?.selectedId).toBeNull()
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('keeps idle Claude config options visible for the selected period', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-claude-config-idle-'))
|
|
|
|
try {
|
|
const work = join(home, 'claude-work')
|
|
const personal = join(home, 'claude-personal')
|
|
await mkdir(join(work, 'projects', 'app'), { recursive: true })
|
|
await mkdir(join(personal, 'projects', 'app'), { recursive: true })
|
|
|
|
await writeFile(
|
|
join(work, 'projects', 'app', 'work.jsonl'),
|
|
[
|
|
userLine('work', '2026-04-10T11:59:00Z'),
|
|
assistantLine('work', '2026-04-10T12:00:00Z', 'msg-work'),
|
|
].join('\n'),
|
|
)
|
|
await writeFile(
|
|
join(personal, 'projects', 'app', 'personal.jsonl'),
|
|
[
|
|
userLine('personal', '2026-04-09T11:59:00Z'),
|
|
assistantLine('personal', '2026-04-09T12:00:00Z', 'msg-personal'),
|
|
].join('\n'),
|
|
)
|
|
|
|
const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) }
|
|
const allResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--day', '2026-04-10',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(allResult.status, `stderr: ${allResult.stderr}`).toBe(0)
|
|
const allPayload = JSON.parse(allResult.stdout) as {
|
|
current: { calls: number }
|
|
claudeConfigs?: { options: Array<{ id: string; label: string }> }
|
|
}
|
|
expect(allPayload.current.calls).toBe(1)
|
|
expect(allPayload.claudeConfigs?.options.map(o => o.label).sort()).toEqual(['claude-personal', 'claude-work'])
|
|
|
|
const personalSourceId = allPayload.claudeConfigs!.options.find(o => o.label === 'claude-personal')!.id
|
|
const personalResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--day', '2026-04-10',
|
|
'--provider', 'all',
|
|
'--claude-config-source', personalSourceId,
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(personalResult.status, `stderr: ${personalResult.stderr}`).toBe(0)
|
|
const personalPayload = JSON.parse(personalResult.stdout) as {
|
|
current: { calls: number; sessions: number; providers: Record<string, number> }
|
|
claudeConfigs?: { selectedId: string | null }
|
|
}
|
|
expect(personalPayload.claudeConfigs?.selectedId).toBe(personalSourceId)
|
|
expect(personalPayload.current.calls).toBe(0)
|
|
expect(personalPayload.current.sessions).toBe(0)
|
|
expect(personalPayload.current.providers).toEqual({ claude: 0 })
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('rejects --claude-config-source combined with a non-Claude --provider', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-cfg-provider-'))
|
|
try {
|
|
const work = join(home, 'claude-work')
|
|
const personal = join(home, 'claude-personal')
|
|
await mkdir(join(work, 'projects', 'app'), { recursive: true })
|
|
await mkdir(join(personal, 'projects', 'app'), { recursive: true })
|
|
const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) }
|
|
|
|
const result = runCli([
|
|
'status', '--format', 'menubar-json', '--period', 'all',
|
|
'--provider', 'codex', '--claude-config-source', 'claude-config:whatever',
|
|
'--no-optimize',
|
|
], home, env)
|
|
|
|
expect(result.status).not.toBe(0)
|
|
expect(result.stderr).toContain('--claude-config-source cannot be combined with --provider codex')
|
|
|
|
// 'claude' is allowed (a config scopes Claude usage).
|
|
const okClaude = runCli([
|
|
'status', '--format', 'menubar-json', '--period', 'all',
|
|
'--provider', 'claude', '--no-optimize',
|
|
], home, env)
|
|
expect(okClaude.status, `stderr: ${okClaude.stderr}`).toBe(0)
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('surfaces Claude Desktop sessions as their own bucket so config sum equals All', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-desktop-'))
|
|
try {
|
|
const work = join(home, 'claude-work')
|
|
const personal = join(home, 'claude-personal')
|
|
await mkdir(join(work, 'projects', 'app'), { recursive: true })
|
|
await mkdir(join(personal, 'projects', 'app'), { recursive: true })
|
|
await writeFile(join(work, 'projects', 'app', 'w.jsonl'),
|
|
[userLine('w', '2026-04-10T11:59:00Z'), assistantLine('w', '2026-04-10T12:00:00Z', 'mw')].join('\n'))
|
|
await writeFile(join(personal, 'projects', 'app', 'p.jsonl'),
|
|
[userLine('p', '2026-04-10T12:59:00Z'), assistantLine('p', '2026-04-10T13:00:00Z', 'mp')].join('\n'))
|
|
|
|
// A fake Claude Desktop sessions tree.
|
|
const desktop = join(home, 'desktop-sessions')
|
|
const dProj = join(desktop, 'appid', 'ws', 'local_s1', '.claude', 'projects', 'space')
|
|
await mkdir(dProj, { recursive: true })
|
|
await writeFile(join(dProj, 'd.jsonl'),
|
|
[userLine('d', '2026-04-10T13:59:00Z'), assistantLine('d', '2026-04-10T14:00:00Z', 'md')].join('\n'))
|
|
|
|
const env = {
|
|
CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter),
|
|
CODEBURN_DESKTOP_SESSIONS_DIR: desktop,
|
|
}
|
|
const result = runCli([
|
|
'status', '--format', 'menubar-json', '--period', 'all', '--provider', 'all', '--no-optimize',
|
|
], home, env)
|
|
expect(result.status, `stderr: ${result.stderr}`).toBe(0)
|
|
const payload = JSON.parse(result.stdout) as {
|
|
current: { calls: number }
|
|
claudeConfigs?: { options: Array<{ id: string; label: string }> }
|
|
}
|
|
// 3 sessions total: work + personal + desktop.
|
|
expect(payload.current.calls).toBe(3)
|
|
// The selector lists all three, including a Claude Desktop bucket.
|
|
const labels = payload.claudeConfigs?.options.map(o => o.label).sort()
|
|
expect(labels).toContain('Claude Desktop')
|
|
expect(labels).toHaveLength(3)
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('includes LingTai TUI usage and activity categories in menubar payloads', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-lingtai-'))
|
|
|
|
try {
|
|
const lingtaiHome = join(home, '.lingtai')
|
|
const agentDir = join(lingtaiHome, 'agent')
|
|
await mkdir(join(agentDir, 'logs'), { recursive: true })
|
|
await writeFile(join(agentDir, '.agent.json'), JSON.stringify({
|
|
agent_id: 'agent-1',
|
|
agent_name: 'LingTai Agent',
|
|
llm: { model: 'gpt-4o' },
|
|
}))
|
|
|
|
const now = new Date()
|
|
const h = now.getUTCHours()
|
|
const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000)
|
|
const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts3 = new Date(base.getTime() + 120_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
|
|
await writeFile(
|
|
join(agentDir, 'logs', 'token_ledger.jsonl'),
|
|
[
|
|
JSON.stringify({ source: 'main', ts: ts1, input: 1000, cached: 100, output: 100, model: 'gpt-4o' }),
|
|
JSON.stringify({ source: 'tc_wake', ts: ts2, input: 2000, cached: 500, output: 200, model: 'gpt-4o' }),
|
|
JSON.stringify({ source: 'summarize_apriori', ts: ts3, input: 1500, cached: 300, output: 150, model: 'gpt-4o' }),
|
|
].join('\n') + '\n',
|
|
)
|
|
|
|
const result = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--period', 'today',
|
|
'--provider', 'lingtai-tui',
|
|
'--no-optimize',
|
|
], home, {
|
|
LINGTAI_HOME: lingtaiHome,
|
|
LINGTAI_TUI_GLOBAL_DIR: join(home, '.lingtai-tui'),
|
|
})
|
|
|
|
expect(result.status, `stderr: ${result.stderr}`).toBe(0)
|
|
|
|
const payload = JSON.parse(result.stdout) as {
|
|
current: {
|
|
cost: number
|
|
calls: number
|
|
providers: Record<string, number>
|
|
topActivities: Array<{ name: string; turns: number }>
|
|
}
|
|
}
|
|
|
|
expect(payload.current.cost).toBeGreaterThan(0)
|
|
expect(payload.current.calls).toBe(3)
|
|
expect(payload.current.providers['lingtai tui']).toBeGreaterThan(0)
|
|
expect(payload.current.topActivities.map(a => a.name).sort()).toEqual([
|
|
'Conversation',
|
|
'Delegation',
|
|
'Planning',
|
|
])
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('attaches combined local-only usage for --scope combined and omits it for local scope', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-combined-'))
|
|
|
|
try {
|
|
const projectDir = join(home, '.claude', 'projects', 'myapp')
|
|
await mkdir(projectDir, { recursive: true })
|
|
|
|
const now = new Date()
|
|
const h = now.getUTCHours()
|
|
const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000)
|
|
const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
|
|
await writeFile(
|
|
join(projectDir, 'session.jsonl'),
|
|
[
|
|
userLine('s1', ts1),
|
|
assistantLine('s1', ts2, 'msg-1'),
|
|
].join('\n'),
|
|
)
|
|
|
|
const combinedResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--scope', 'combined',
|
|
'--period', 'today',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home)
|
|
|
|
expect(combinedResult.status, `stderr: ${combinedResult.stderr}`).toBe(0)
|
|
|
|
const payload = JSON.parse(combinedResult.stdout) as {
|
|
current: {
|
|
cost: number
|
|
calls: number
|
|
sessions: number
|
|
inputTokens: number
|
|
outputTokens: number
|
|
}
|
|
history: {
|
|
daily: Array<{ cacheWriteTokens?: number; cacheReadTokens?: number }>
|
|
}
|
|
combined?: {
|
|
perDevice: Array<{
|
|
id: string
|
|
local: boolean
|
|
cost: number
|
|
calls: number
|
|
sessions: number
|
|
inputTokens: number
|
|
outputTokens: number
|
|
cacheCreateTokens: number
|
|
cacheReadTokens: number
|
|
totalTokens: number
|
|
}>
|
|
combined: {
|
|
cost: number
|
|
calls: number
|
|
sessions: number
|
|
inputTokens: number
|
|
outputTokens: number
|
|
cacheCreateTokens: number
|
|
cacheReadTokens: number
|
|
totalTokens: number
|
|
deviceCount: number
|
|
reachableCount: number
|
|
}
|
|
}
|
|
}
|
|
|
|
expect(payload.combined).toBeDefined()
|
|
expect(payload.combined!.perDevice).toHaveLength(1)
|
|
const local = payload.combined!.perDevice[0]!
|
|
const cacheCreateTokens = payload.history.daily.reduce((sum, d) => sum + (d.cacheWriteTokens ?? 0), 0)
|
|
const cacheReadTokens = payload.history.daily.reduce((sum, d) => sum + (d.cacheReadTokens ?? 0), 0)
|
|
const totalTokens = payload.current.inputTokens + payload.current.outputTokens + cacheCreateTokens + cacheReadTokens
|
|
|
|
expect(local).toMatchObject({
|
|
id: 'local',
|
|
local: true,
|
|
cost: payload.current.cost,
|
|
calls: payload.current.calls,
|
|
sessions: payload.current.sessions,
|
|
inputTokens: payload.current.inputTokens,
|
|
outputTokens: payload.current.outputTokens,
|
|
cacheCreateTokens,
|
|
cacheReadTokens,
|
|
totalTokens,
|
|
})
|
|
expect(payload.combined!.combined).toEqual({
|
|
cost: payload.current.cost,
|
|
calls: payload.current.calls,
|
|
sessions: payload.current.sessions,
|
|
inputTokens: payload.current.inputTokens,
|
|
outputTokens: payload.current.outputTokens,
|
|
cacheCreateTokens,
|
|
cacheReadTokens,
|
|
totalTokens,
|
|
deviceCount: 1,
|
|
reachableCount: 1,
|
|
})
|
|
|
|
const localResult = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--scope', 'local',
|
|
'--period', 'today',
|
|
'--provider', 'all',
|
|
'--no-optimize',
|
|
], home)
|
|
expect(localResult.status, `stderr: ${localResult.stderr}`).toBe(0)
|
|
expect(JSON.parse(localResult.stdout)).not.toHaveProperty('combined')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it.each([
|
|
['--provider', ['--provider', 'claude']],
|
|
['--project', ['--project', 'x']],
|
|
['--exclude', ['--exclude', 'y']],
|
|
])('rejects combined scope with filtered local payloads from %s', async (_name, filterArgs) => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-combined-filter-'))
|
|
|
|
try {
|
|
const result = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--scope', 'combined',
|
|
...filterArgs,
|
|
'--no-optimize',
|
|
], home)
|
|
|
|
expect(result.status).toBe(1)
|
|
expect(result.stderr).toContain('error: --scope combined cannot be combined with --provider, --project, or --exclude (paired devices report unfiltered usage)')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('rejects invalid menubar-json scope values', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-scope-'))
|
|
|
|
try {
|
|
const result = runCli([
|
|
'status',
|
|
'--format', 'menubar-json',
|
|
'--scope', 'remote',
|
|
'--no-optimize',
|
|
], home)
|
|
|
|
expect(result.status).toBe(1)
|
|
expect(result.stderr).toContain('unknown scope "remote"')
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
it('still emits a valid combined menubar payload when the remotes store is corrupt', async () => {
|
|
const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-corrupt-remotes-'))
|
|
|
|
try {
|
|
const projectDir = join(home, '.claude', 'projects', 'myapp')
|
|
await mkdir(projectDir, { recursive: true })
|
|
const now = new Date()
|
|
const h = now.getUTCHours()
|
|
const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000)
|
|
const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z')
|
|
const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z')
|
|
await writeFile(join(projectDir, 'session.jsonl'), [userLine('s1', ts1), assistantLine('s1', ts2, 'msg-1')].join('\n'))
|
|
|
|
// Corrupt the remotes store the combined path reads. The menubar must
|
|
// still get a valid payload (combined degrades to local-only).
|
|
const sharingDir = join(home, '.config', 'codeburn', 'sharing')
|
|
await mkdir(sharingDir, { recursive: true })
|
|
await writeFile(join(sharingDir, 'remote-devices.json'), '{ this is : not valid json ]')
|
|
|
|
const result = runCli([
|
|
'status', '--format', 'menubar-json', '--scope', 'combined',
|
|
'--period', 'today', '--no-optimize',
|
|
], home)
|
|
|
|
expect(result.status, `stderr: ${result.stderr}`).toBe(0)
|
|
const payload = JSON.parse(result.stdout) as {
|
|
current: { cost: number }
|
|
combined?: { perDevice: unknown[]; combined: { deviceCount: number; reachableCount: number } }
|
|
}
|
|
expect(payload.combined).toBeDefined()
|
|
expect(payload.combined!.perDevice).toHaveLength(1)
|
|
expect(payload.combined!.combined.deviceCount).toBe(1)
|
|
expect(payload.combined!.combined.reachableCount).toBe(1)
|
|
} finally {
|
|
await rm(home, { recursive: true, force: true })
|
|
}
|
|
})
|
|
})
|