{activeTab === 'providers' &&
}
{activeTab === 'permissions' &&
}
+ {activeTab === 'activity' &&
}
{activeTab === 'general' &&
}
{activeTab === 'adapters' &&
}
{activeTab === 'terminal' &&
}
diff --git a/desktop/src/stores/uiStore.ts b/desktop/src/stores/uiStore.ts
index 0d9630b8..1e4f8cfc 100644
--- a/desktop/src/stores/uiStore.ts
+++ b/desktop/src/stores/uiStore.ts
@@ -31,6 +31,7 @@ export type Toast = {
export type SettingsTab =
| 'providers'
| 'permissions'
+ | 'activity'
| 'general'
| 'adapters'
| 'terminal'
diff --git a/src/server/__tests__/settings.test.ts b/src/server/__tests__/settings.test.ts
index 035d69a6..1bc3bbc1 100644
--- a/src/server/__tests__/settings.test.ts
+++ b/src/server/__tests__/settings.test.ts
@@ -2,7 +2,7 @@
* Unit tests for Settings, Models, and Status APIs
*/
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'bun:test'
import * as fs from 'fs/promises'
import * as path from 'path'
import * as os from 'os'
@@ -702,3 +702,59 @@ describe('Status API', () => {
expect(res.status).toBe(404)
})
})
+
+// =============================================================================
+// Activity Stats API
+// =============================================================================
+
+describe('Activity Stats API', () => {
+ let handleApiRequest: typeof import('../router.js').handleApiRequest
+
+ beforeAll(async () => {
+ ;({ handleApiRequest } = await import('../router.js'))
+ })
+
+ beforeEach(async () => {
+ await setup()
+ })
+
+ afterEach(teardown)
+
+ it('GET /api/activity-stats should default to the all range', async () => {
+ const { req, url } = makeRequest('GET', '/api/activity-stats')
+ const res = await handleApiRequest(req, url)
+
+ expect(res.status).toBe(200)
+
+ const body = await res.json()
+ expect(body.range).toBe('all')
+ expect(body.stats.totalSessions).toBe(0)
+ expect(new Date(body.generatedAt).toString()).not.toBe('Invalid Date')
+ })
+
+ it('GET /api/activity-stats/:range should return stats for supported ranges', async () => {
+ for (const range of ['7d', '30d', 'all'] as const) {
+ const { req, url } = makeRequest('GET', `/api/activity-stats/${range}`)
+ const res = await handleApiRequest(req, url)
+
+ expect(res.status).toBe(200)
+ const body = await res.json()
+ expect(body.range).toBe(range)
+ expect(body.stats).toBeDefined()
+ }
+ })
+
+ it('should reject non-GET methods', async () => {
+ const { req, url } = makeRequest('POST', '/api/activity-stats')
+ const res = await handleApiRequest(req, url)
+
+ expect(res.status).toBe(405)
+ })
+
+ it('should reject unknown activity stats ranges', async () => {
+ const { req, url } = makeRequest('GET', '/api/activity-stats/90d')
+ const res = await handleApiRequest(req, url)
+
+ expect(res.status).toBe(400)
+ })
+})
diff --git a/src/server/api/activityStats.ts b/src/server/api/activityStats.ts
new file mode 100644
index 00000000..9829dfb3
--- /dev/null
+++ b/src/server/api/activityStats.ts
@@ -0,0 +1,43 @@
+import {
+ aggregateClaudeCodeStatsForRange,
+ type StatsDateRange,
+} from '../../utils/stats.js'
+import { ApiError, errorResponse } from '../middleware/errorHandler.js'
+
+const VALID_RANGES = new Set
(['7d', '30d', 'all'])
+
+export async function handleActivityStatsApi(
+ req: Request,
+ _url: URL,
+ segments: string[],
+): Promise {
+ try {
+ if (req.method !== 'GET') {
+ throw methodNotAllowed(req.method)
+ }
+
+ const requestedRange = segments[2]
+ const range: StatsDateRange = requestedRange === undefined ? 'all' : parseRange(requestedRange)
+ const stats = await aggregateClaudeCodeStatsForRange(range)
+
+ return Response.json({
+ stats,
+ range,
+ generatedAt: new Date().toISOString(),
+ })
+ } catch (error) {
+ return errorResponse(error)
+ }
+}
+
+function parseRange(range: string): StatsDateRange {
+ if (VALID_RANGES.has(range as StatsDateRange)) {
+ return range as StatsDateRange
+ }
+
+ throw ApiError.badRequest(`Unknown activity stats range: ${range}`)
+}
+
+function methodNotAllowed(method: string): ApiError {
+ return new ApiError(405, `Method ${method} not allowed`, 'METHOD_NOT_ALLOWED')
+}
diff --git a/src/server/router.ts b/src/server/router.ts
index 614a8880..5db9be15 100644
--- a/src/server/router.ts
+++ b/src/server/router.ts
@@ -23,6 +23,7 @@ import { handleMcpApi } from './api/mcp.js'
import { handleDiagnosticsApi } from './api/diagnostics.js'
import { handleDoctorApi } from './api/doctor.js'
import { handleH5AccessApi } from './api/h5-access.js'
+import { handleActivityStatsApi } from './api/activityStats.js'
export async function handleApiRequest(req: Request, url: URL): Promise {
const path = url.pathname
@@ -103,6 +104,9 @@ export async function handleApiRequest(req: Request, url: URL): Promise JSON.stringify(entry)).join('\n')}\n`,
+ 'utf-8',
+ )
+}
+
+function projectFile(sessionId: string): string {
+ return join(tmpConfigDir, 'projects', 'test-project', `${sessionId}.jsonl`)
+}
+
+function subagentFile(sessionId: string, agentId: string): string {
+ return join(
+ tmpConfigDir,
+ 'projects',
+ 'test-project',
+ sessionId,
+ 'subagents',
+ `agent-${agentId}.jsonl`,
+ )
+}
+
+function totalForDate(
+ dailyModelTokens: Array<{
+ date: string
+ tokensByModel: { [model: string]: number }
+ }>,
+ date: string,
+): number {
+ return Object.values(
+ dailyModelTokens.find(day => day.date === date)?.tokensByModel ?? {},
+ ).reduce((sum, tokens) => sum + tokens, 0)
+}
+
+describe('activity stats token accounting', () => {
+ beforeEach(async () => {
+ originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+ tmpConfigDir = await mkdtemp(join(tmpdir(), 'cc-haha-stats-'))
+ process.env.CLAUDE_CONFIG_DIR = tmpConfigDir
+ })
+
+ afterEach(async () => {
+ if (originalConfigDir === undefined) {
+ delete process.env.CLAUDE_CONFIG_DIR
+ } else {
+ process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+ }
+ await rm(tmpConfigDir, { recursive: true, force: true })
+ })
+
+ it('buckets assistant usage by message date and includes cache tokens', async () => {
+ const sessionStart = dateKey(-2)
+ const nextDay = dateKey(-1)
+
+ await writeJsonl(projectFile('cross-midnight'), [
+ userEntry('user-1', at(sessionStart, '23:55:00')),
+ assistantEntry(
+ 'assistant-1',
+ at(sessionStart, '23:58:00'),
+ { input_tokens: 1, output_tokens: 2 },
+ { parentUuid: 'user-1' },
+ ),
+ assistantEntry(
+ 'assistant-2',
+ at(nextDay, '00:05:00'),
+ {
+ input_tokens: 10,
+ output_tokens: 20,
+ cache_read_input_tokens: 30,
+ cache_creation_input_tokens: 40,
+ },
+ { parentUuid: 'assistant-1' },
+ ),
+ ])
+
+ const stats = await aggregateClaudeCodeStatsForRange('all')
+
+ expect(totalForDate(stats.dailyModelTokens, sessionStart)).toBe(3)
+ expect(totalForDate(stats.dailyModelTokens, nextDay)).toBe(100)
+ expect(stats.dailyActivity.find(day => day.date === sessionStart)).toMatchObject({
+ sessionCount: 1,
+ })
+ expect(stats.dailyActivity.find(day => day.date === nextDay)).toMatchObject({
+ sessionCount: 1,
+ })
+ expect(stats.modelUsage['claude-test']).toMatchObject({
+ inputTokens: 11,
+ outputTokens: 22,
+ cacheReadInputTokens: 30,
+ cacheCreationInputTokens: 40,
+ })
+ })
+
+ it('counts subagent tokens without counting subagent transcripts as sessions', async () => {
+ const today = dateKey(0)
+
+ await writeJsonl(projectFile('parent-session'), [
+ userEntry('parent-user', at(today, '10:00:00')),
+ assistantEntry(
+ 'parent-assistant',
+ at(today, '10:01:00'),
+ { input_tokens: 5, output_tokens: 5 },
+ { parentUuid: 'parent-user' },
+ ),
+ ])
+ await writeJsonl(subagentFile('parent-session', '001'), [
+ userEntry('agent-user', at(today, '10:02:00'), true),
+ assistantEntry(
+ 'agent-assistant',
+ at(today, '10:03:00'),
+ {
+ input_tokens: 7,
+ output_tokens: 8,
+ cache_read_input_tokens: 9,
+ },
+ { isSidechain: true, parentUuid: 'agent-user' },
+ ),
+ ])
+
+ const stats = await aggregateClaudeCodeStatsForRange('all')
+
+ expect(stats.totalSessions).toBe(1)
+ expect(stats.dailyActivity.find(day => day.date === today)).toMatchObject({
+ sessionCount: 1,
+ messageCount: 2,
+ })
+ expect(totalForDate(stats.dailyModelTokens, today)).toBe(34)
+ })
+
+ it('keeps resumed old sessions in range token totals with active daily session counts', async () => {
+ const oldDate = dateKey(-50)
+ const inRangeDate = dateKey(-1)
+
+ await writeJsonl(projectFile('resumed-old-session'), [
+ userEntry('old-user', at(oldDate, '08:00:00')),
+ assistantEntry(
+ 'recent-assistant',
+ at(inRangeDate, '09:00:00'),
+ { input_tokens: 12, output_tokens: 13 },
+ { parentUuid: 'old-user' },
+ ),
+ ])
+
+ const stats = await aggregateClaudeCodeStatsForRange('30d')
+
+ expect(stats.totalSessions).toBe(0)
+ expect(totalForDate(stats.dailyModelTokens, inRangeDate)).toBe(25)
+ expect(totalForDate(stats.dailyModelTokens, oldDate)).toBe(0)
+ expect(stats.dailyActivity.find(day => day.date === inRangeDate)).toMatchObject({
+ sessionCount: 1,
+ })
+ expect(stats.dailyActivity.find(day => day.date === oldDate)).toBeUndefined()
+ })
+
+ it('does not include future transcript timestamps in bounded ranges', async () => {
+ const today = dateKey(0)
+ const future = dateKey(3)
+
+ await writeJsonl(projectFile('future-session'), [
+ userEntry('today-user', at(today, '10:00:00')),
+ assistantEntry(
+ 'future-assistant',
+ at(future, '10:00:00'),
+ { input_tokens: 100, output_tokens: 100 },
+ { parentUuid: 'today-user' },
+ ),
+ ])
+
+ const stats = await aggregateClaudeCodeStatsForRange('7d')
+
+ expect(totalForDate(stats.dailyModelTokens, future)).toBe(0)
+ })
+
+ it('invalidates pre-v5 stats caches because daily activity accounting changed', async () => {
+ await mkdir(tmpConfigDir, { recursive: true })
+ await writeFile(
+ join(tmpConfigDir, 'stats-cache.json'),
+ JSON.stringify({
+ version: 3,
+ lastComputedDate: dateKey(-1),
+ dailyActivity: [{ date: dateKey(-1), messageCount: 1, sessionCount: 1, toolCallCount: 0 }],
+ dailyModelTokens: [{ date: dateKey(-1), tokensByModel: { stale: 1 } }],
+ modelUsage: {},
+ totalSessions: 1,
+ totalMessages: 1,
+ longestSession: null,
+ firstSessionDate: null,
+ hourCounts: {},
+ totalSpeculationTimeSavedMs: 0,
+ }),
+ 'utf-8',
+ )
+
+ const cache = await loadStatsCache()
+
+ expect(STATS_CACHE_VERSION).toBe(5)
+ expect(cache.dailyModelTokens).toEqual([])
+ expect(cache.totalSessions).toBe(0)
+ })
+})
diff --git a/src/utils/stats.ts b/src/utils/stats.ts
index 7b8434ae..f5ee0ed6 100644
--- a/src/utils/stats.ts
+++ b/src/utils/stats.ts
@@ -32,7 +32,7 @@ export type DailyActivity = {
export type DailyModelTokens = {
date: string // YYYY-MM-DD format
- tokensByModel: { [modelName: string]: number } // total tokens (input + output) per model
+ tokensByModel: { [modelName: string]: number } // total tokens (input + output + cache read + cache creation) per model
}
export type StreakInfo = {
@@ -110,6 +110,40 @@ type ProcessOptions = {
toDate?: string
}
+type UsageLike = {
+ input_tokens?: number
+ output_tokens?: number
+ cache_read_input_tokens?: number
+ cache_creation_input_tokens?: number
+}
+
+function getTotalUsageTokens(usage: UsageLike): number {
+ return (
+ (usage.input_tokens || 0) +
+ (usage.output_tokens || 0) +
+ (usage.cache_read_input_tokens || 0) +
+ (usage.cache_creation_input_tokens || 0)
+ )
+}
+
+function isDateInRange(
+ date: string,
+ fromDate?: string,
+ toDate?: string,
+): boolean {
+ if (fromDate && isDateBefore(date, fromDate)) return false
+ if (toDate && isDateBefore(toDate, date)) return false
+ return true
+}
+
+function getMessageDateKey(
+ message: Pick,
+): string | null {
+ const messageTimestamp = new Date(message.timestamp)
+ if (isNaN(messageTimestamp.getTime())) return null
+ return toDateString(messageTimestamp)
+}
+
/**
* Process session files and extract stats.
* Can filter by date range.
@@ -122,6 +156,7 @@ async function processSessionFiles(
const fs = getFsImplementation()
const dailyActivityMap = new Map()
+ const dailySessionIdsMap = new Map>()
const dailyModelTokensMap = new Map()
const sessions: SessionStats[] = []
const hourCounts = new Map()
@@ -134,6 +169,30 @@ async function processSessionFiles(
// Track parent sessions that already recorded a shot count (dedup across subagents)
const sessionsWithShotCount = new Set()
+ const getDailyActivity = (date: string): DailyActivity => {
+ let activity = dailyActivityMap.get(date)
+ if (!activity) {
+ activity = {
+ date,
+ messageCount: 0,
+ sessionCount: 0,
+ toolCallCount: 0,
+ }
+ dailyActivityMap.set(date, activity)
+ }
+ return activity
+ }
+
+ const markSessionActiveOnDate = (date: string, parentSessionId: string) => {
+ let sessionIds = dailySessionIdsMap.get(date)
+ if (!sessionIds) {
+ sessionIds = new Set()
+ dailySessionIdsMap.set(date, sessionIds)
+ }
+ sessionIds.add(parentSessionId)
+ getDailyActivity(date)
+ }
+
// Process session files in parallel batches for better performance
const BATCH_SIZE = 20
for (let i = 0; i < sessionFiles.length; i += BATCH_SIZE) {
@@ -143,7 +202,6 @@ async function processSessionFiles(
try {
// If we have a fromDate filter, skip files that haven't been modified since then
if (fromDate) {
- let fileSize = 0
try {
const fileStat = await fs.stat(sessionFile)
const fileModifiedDate = toDateString(fileStat.mtime)
@@ -155,24 +213,9 @@ async function processSessionFiles(
skipped: true,
}
}
- fileSize = fileStat.size
} catch {
// If we can't stat the file, try to read it anyway
}
- // For large files, peek at the session start date before reading everything.
- // Sessions that pass the mtime filter but started before fromDate are skipped
- // (e.g. a month-old session resumed today gets a new mtime write but old start date).
- if (fileSize > 65536) {
- const startDate = await readSessionStartDate(sessionFile)
- if (startDate && isDateBefore(startDate, fromDate)) {
- return {
- sessionFile,
- entries: null,
- error: null,
- skipped: true,
- }
- }
- }
}
const entries = await readJSONLFile(sessionFile)
return { sessionFile, entries, error: null, skipped: false }
@@ -207,15 +250,14 @@ async function processSessionFiles(
// Subagent transcripts mark all messages as sidechain. We still want
// their token usage counted, but not as separate sessions.
const isSubagentFile = sessionFile.includes(`${sep}subagents${sep}`)
+ const parentSessionId = isSubagentFile
+ ? basename(dirname(dirname(sessionFile)))
+ : sessionId
// Extract shot count from PR attribution in gh pr create calls (ant-only)
// This must run before the sidechain filter since subagent transcripts
// mark all messages as sidechain
if (feature('SHOT_STATS') && shotDistributionMap) {
- const parentSessionId = isSubagentFile
- ? basename(dirname(dirname(sessionFile)))
- : sessionId
-
if (!sessionsWithShotCount.has(parentSessionId)) {
const shotCount = extractShotCountFromMessages(messages)
if (shotCount !== null) {
@@ -253,21 +295,12 @@ async function processSessionFiles(
}
const dateKey = toDateString(firstTimestamp)
+ const includeSessionInRange = isDateInRange(dateKey, fromDate, toDate)
- // Apply date filters
- if (fromDate && isDateBefore(dateKey, fromDate)) continue
- if (toDate && isDateBefore(toDate, dateKey)) continue
-
- // Track daily activity (use first message date as session date)
- const existing = dailyActivityMap.get(dateKey) || {
- date: dateKey,
- messageCount: 0,
- sessionCount: 0,
- toolCallCount: 0,
- }
-
- // Subagent files contribute tokens and tool calls, but aren't sessions.
- if (!isSubagentFile) {
+ // Session-level aggregates still represent newly started top-level
+ // sessions. Daily activity is tracked below by each message date so token
+ // totals and visible per-day session counts share one date bucket.
+ if (!isSubagentFile && includeSessionInRange) {
const duration = lastTimestamp.getTime() - firstTimestamp.getTime()
sessions.push({
@@ -279,28 +312,34 @@ async function processSessionFiles(
totalMessages += mainMessages.length
- existing.sessionCount++
- existing.messageCount += mainMessages.length
-
const hour = firstTimestamp.getHours()
hourCounts.set(hour, (hourCounts.get(hour) || 0) + 1)
}
- if (!isSubagentFile || dailyActivityMap.has(dateKey)) {
- dailyActivityMap.set(dateKey, existing)
- }
-
// Process messages for tool usage and model stats
for (const message of mainMessages) {
+ const messageDateKey = getMessageDateKey(message)
+ const includeMessageInRange =
+ messageDateKey !== null &&
+ isDateInRange(messageDateKey, fromDate, toDate)
+
+ if (includeMessageInRange && messageDateKey !== null) {
+ markSessionActiveOnDate(messageDateKey, parentSessionId)
+ if (!isSubagentFile) {
+ getDailyActivity(messageDateKey).messageCount++
+ }
+ }
+
if (message.type === 'assistant') {
const content = message.message?.content
- if (Array.isArray(content)) {
+ if (
+ includeMessageInRange &&
+ messageDateKey !== null &&
+ Array.isArray(content)
+ ) {
for (const block of content) {
if (block.type === 'tool_use') {
- const activity = dailyActivityMap.get(dateKey)
- if (activity) {
- activity.toolCallCount++
- }
+ getDailyActivity(messageDateKey).toolCallCount++
}
}
}
@@ -315,6 +354,10 @@ async function processSessionFiles(
continue
}
+ if (!includeMessageInRange || messageDateKey === null) {
+ continue
+ }
+
if (!modelUsageAgg[model]) {
modelUsageAgg[model] = {
inputTokens: 0,
@@ -336,12 +379,12 @@ async function processSessionFiles(
usage.cache_creation_input_tokens || 0
// Track daily tokens per model
- const totalTokens =
- (usage.input_tokens || 0) + (usage.output_tokens || 0)
+ const totalTokens = getTotalUsageTokens(usage)
if (totalTokens > 0) {
- const dayTokens = dailyModelTokensMap.get(dateKey) || {}
+ const tokenDateKey = messageDateKey
+ const dayTokens = dailyModelTokensMap.get(tokenDateKey) || {}
dayTokens[model] = (dayTokens[model] || 0) + totalTokens
- dailyModelTokensMap.set(dateKey, dayTokens)
+ dailyModelTokensMap.set(tokenDateKey, dayTokens)
}
}
}
@@ -349,6 +392,10 @@ async function processSessionFiles(
}
}
+ for (const [date, sessionIds] of dailySessionIdsMap) {
+ getDailyActivity(date).sessionCount = sessionIds.size
+ }
+
return {
dailyActivity: Array.from(dailyActivityMap.values()).sort((a, b) =>
a.date.localeCompare(b.date),
@@ -733,10 +780,12 @@ export async function aggregateClaudeCodeStatsForRange(
const fromDate = new Date(today)
fromDate.setDate(today.getDate() - daysBack + 1) // +1 to include today
const fromDateStr = toDateString(fromDate)
+ const toDateStr = toDateString(today)
// Process session files for the date range
const stats = await processSessionFiles(allSessionFiles, {
fromDate: fromDateStr,
+ toDate: toDateStr,
})
return processedStatsToClaudeCodeStats(stats)
diff --git a/src/utils/statsCache.ts b/src/utils/statsCache.ts
index 109268d7..4bafe631 100644
--- a/src/utils/statsCache.ts
+++ b/src/utils/statsCache.ts
@@ -11,8 +11,8 @@ import { logError } from './log.js'
import { jsonParse, jsonStringify } from './slowOperations.js'
import type { DailyActivity, DailyModelTokens, SessionStats } from './stats.js'
-export const STATS_CACHE_VERSION = 3
-const MIN_MIGRATABLE_VERSION = 1
+export const STATS_CACHE_VERSION = 5
+const MIN_MIGRATABLE_VERSION = 5
const STATS_CACHE_FILENAME = 'stats-cache.json'
/**
@@ -99,10 +99,10 @@ function getEmptyCache(): PersistedStatsCache {
* Migrate an older cache to the current schema.
* Returns null if the version is unknown or too old to migrate.
*
- * Preserves historical aggregates that would otherwise be lost when
- * transcript files have already aged out past cleanupPeriodDays.
- * Pre-migration days may undercount (e.g. v2 lacked subagent tokens);
- * we accept that rather than drop the history.
+ * Daily activity accounting changed in v5 to count per-day active parent
+ * sessions from message timestamps instead of session-start dates. Older
+ * caches are intentionally rejected so the next aggregation recomputes daily
+ * session counts and token buckets with the same date semantics.
*/
function migrateStatsCache(
parsed: Partial & { version: number },