@brimveyn/aimux 1.22.10 → 1.22.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.22.10",
+  "version": "1.22.12",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, Kimi side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -66,7 +66,7 @@
     "bump:terminal_manager": "bun run scripts/bump-protocol.ts terminal-manager"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.10.0",
+    "@brimveyn/aimux-config": "0.10.1",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/index.tsx

@@ -51,6 +51,13 @@ if (command === 'update') {
   process.exit(await runUpdate())
 }
 
+// Spawned detached by `maybeSpawnUsageRollup` below. Walks hundreds of MB of
+// assistant JSONL, so it gets its own process and never shares one with the UI.
+if (command === 'usage-rollup') {
+  const { runUsageRollup } = await import('./services/usage-history/rollup')
+  process.exit(await runUsageRollup())
+}
+
 const { logDebug } = await import('./debug/input-log')
 const { getRuntimeProfile } = await import('./daemon/runtime-paths')
 const runtimeProfile = getRuntimeProfile()
@@ -87,6 +94,7 @@ const [
   { setHostPalette },
   { createSessionBackend },
   { maybeAutoInstallCompletion },
+  { maybeSpawnUsageRollup },
 ] = await Promise.all([
   import('@opentui/react'),
   import('./app'),
@@ -95,6 +103,7 @@ const [
   import('./ui/host-palette'),
   import('./session-backend/bootstrap'),
   import('./cli/completion/install'),
+  import('./services/usage-history/store'),
 ])
 const { resolved: resolvedConfig, user: userConfig } = await loadUserConfig()
 
@@ -104,6 +113,12 @@ const { resolved: resolvedConfig, user: userConfig } = await loadUserConfig()
 // AIMUX_NO_COMPLETION_INSTALL=1; `aimux doctor` reports what landed where.
 maybeAutoInstallCompletion()
 
+// Snapshot today's AI usage before Claude Code prunes the transcripts it came
+// from — roughly a month survives on disk, so the aggregates aimux keeps are
+// the only long-term record. Detached subprocess, at most once per ~day, never
+// blocking. Opt out with AIMUX_NO_USAGE_ROLLUP=1.
+maybeSpawnUsageRollup()
+
 const renderer = await createCliRenderer({
   autoFocus: true,
   // Transparent clear color so cells untouched by BoxRenderable paints (e.g.

package/src/integrations/claude-hooks-install.ts

@@ -6,11 +6,11 @@
 // Hooks reference: https://code.claude.com/docs/en/hooks.md
 
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { logDebug } from '../debug/input-log'
+import { claudeHome } from '../platform/assistant-home'
 
 const HOOK_EVENTS = [
   'UserPromptSubmit',
@@ -34,12 +34,8 @@ interface HookGroupEntry {
   hooks: HookCommandEntry[]
 }
 
-function claudeDir(): string {
-  return join(homedir(), '.claude')
-}
-
 function settingsFilePath(): string {
-  return join(claudeDir(), 'settings.json')
+  return join(claudeHome(), 'settings.json')
 }
 
 function writeAtomic(target: string, contents: string): void {
@@ -180,7 +176,7 @@ export function ensureClaudeSettingsHooks(): boolean {
   parsed.hooks = nextHooks
 
   try {
-    mkdirSync(claudeDir(), { recursive: true })
+    mkdirSync(claudeHome(), { recursive: true })
     writeAtomic(target, `${JSON.stringify(parsed, null, 2)}\n`)
     logDebug('claude-hooks-install:wrote', { events: HOOK_EVENTS, path: target, scriptPath })
     return true

package/src/integrations/claude-theme-sync.ts

@@ -12,24 +12,20 @@ import {
   type ThemeMode,
 } from '@brimveyn/aimux-config'
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 import { logDebug } from '../debug/input-log'
+import { claudeHome } from '../platform/assistant-home'
 
 const THEME_SLUG = 'aimux'
 const THEME_PREF_VALUE = `custom:${THEME_SLUG}`
 
-function claudeDir(): string {
-  return join(homedir(), '.claude')
-}
-
 function themeFilePath(): string {
-  return join(claudeDir(), 'themes', `${THEME_SLUG}.json`)
+  return join(claudeHome(), 'themes', `${THEME_SLUG}.json`)
 }
 
 function settingsFilePath(): string {
-  return join(claudeDir(), 'settings.json')
+  return join(claudeHome(), 'settings.json')
 }
 
 function writeAtomic(target: string, contents: string): void {
@@ -67,7 +63,7 @@ export function syncClaudeTheme(resolved: ResolvedTuiTheme, mode: ThemeMode): vo
 
   const target = themeFilePath()
   try {
-    mkdirSync(join(claudeDir(), 'themes'), { recursive: true })
+    mkdirSync(join(claudeHome(), 'themes'), { recursive: true })
     writeAtomic(target, `${JSON.stringify(theme, null, 2)}\n`)
   } catch (error) {
     logSyncWarn('write-failed', { err: String(error), path: target })
@@ -110,7 +106,7 @@ export function ensureClaudeSettingsThemePref(): void {
   parsed.theme = THEME_PREF_VALUE
 
   try {
-    mkdirSync(claudeDir(), { recursive: true })
+    mkdirSync(claudeHome(), { recursive: true })
     writeAtomic(target, `${JSON.stringify(parsed, null, 2)}\n`)
   } catch (error) {
     logSyncWarn('settings-write-failed', { err: String(error), path: target })

package/src/platform/assistant-home.ts

@@ -0,0 +1,25 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/**
+ * Where each assistant CLI keeps its state.
+ *
+ * Both relocate wholesale through an environment variable, so anything reading
+ * or writing inside those directories has to go through here — three hand-rolled
+ * copies of `join(homedir(), '.claude')` used to disagree about whether
+ * `CLAUDE_CONFIG_DIR` existed, which sent the hook installer and the theme sync
+ * to a directory Claude Code was not reading.
+ */
+function envHome(variable: string, fallback: string): string {
+  const value = process.env[variable]?.trim()
+  if (value != null && value !== '') return value
+  return join(homedir(), fallback)
+}
+
+export function claudeHome(): string {
+  return envHome('CLAUDE_CONFIG_DIR', '.claude')
+}
+
+export function codexHome(): string {
+  return envHome('CODEX_HOME', '.codex')
+}

package/src/platform/daemon-control.ts

@@ -61,14 +61,23 @@ async function waitForSocket(socketPath: string): Promise<boolean> {
   return false
 }
 
-async function spawnDetachedProcess(command: 'daemon' | 'terminal-manager', socketPath: string) {
+/**
+ * Re-run this same aimux with another subcommand, detached and unwatched.
+ *
+ * The entrypoint is resolved from this module rather than `process.argv`, which
+ * points at whatever wrapper or shim launched us.
+ */
+export function spawnDetachedCommand(command: string): void {
   Bun.spawn([process.execPath, 'run', ENTRY_POINT, command], {
     detached: true,
     stderr: 'ignore',
     stdin: 'ignore',
     stdout: 'ignore',
   }).unref()
+}
 
+async function spawnDetachedProcess(command: 'daemon' | 'terminal-manager', socketPath: string) {
+  spawnDetachedCommand(command)
   return waitForSocket(socketPath)
 }
 

package/src/services/ai-usage/adapters/claude.ts

@@ -1,11 +1,11 @@
 import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
 
 import { readFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 import type { UsageSnapshot, UsageWindow, UsageWindowKind } from '../types'
 
+import { claudeHome } from '../../../platform/assistant-home'
 import { computePace, formatTimeRemaining } from '../pace'
 import { runCli } from '../spawn'
 
@@ -81,15 +81,9 @@ function planTierFromPayload(payload: ClaudeCredentialsPayload): string | null {
   return null
 }
 
-function claudeConfigDir(): string {
-  const env = process.env.CLAUDE_CONFIG_DIR?.trim()
-  if (env != null && env !== '') return env
-  return join(homedir(), '.claude')
-}
-
 async function readCredsFromFile(): Promise<string | null> {
   try {
-    const raw = await readFile(join(claudeConfigDir(), '.credentials.json'), 'utf8')
+    const raw = await readFile(join(claudeHome(), '.credentials.json'), 'utf8')
     return raw.trim() || null
   } catch {
     return null

package/src/services/ai-usage/adapters/codex.ts

@@ -1,11 +1,11 @@
 import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
 
 import { readFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 import type { UsageSnapshot, UsageWindow, UsageWindowKind } from '../types'
 
+import { codexHome } from '../../../platform/assistant-home'
 import { computePace, formatTimeRemaining } from '../pace'
 
 interface CodexAuthFile {
@@ -38,12 +38,6 @@ const DEFAULT_CHATGPT_BASE = 'https://chatgpt.com/backend-api'
 const USAGE_PATH = '/wham/usage'
 const AUTH_TIMEOUT_MS = 15_000
 
-function codexHome(): string {
-  const env = process.env.CODEX_HOME?.trim()
-  if (env != null && env !== '') return env
-  return join(homedir(), '.codex')
-}
-
 function parseChatGPTBaseFromConfig(contents: string): string | null {
   for (const rawLine of contents.split(/\r?\n/)) {
     const line = rawLine.split('#', 1)[0]?.trim() ?? ''

package/src/services/usage-history/rollup.ts

@@ -0,0 +1,278 @@
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { logDebug } from '../../debug/input-log'
+import { claudeHome, codexHome } from '../../platform/assistant-home'
+import {
+  emptyDay,
+  localDay,
+  saveUsageHistory,
+  type UsageDay,
+  type UsageDays,
+  type UsageTools,
+} from './store'
+
+/**
+ * Rebuilds the usage aggregates from what the assistants still have on disk.
+ *
+ * Its own process (`aimux usage-rollup`). Nothing here may be imported from the
+ * startup path: it walks hundreds of megabytes of JSONL.
+ */
+
+const FILE_CONCURRENCY = 8
+
+function dayAt(days: UsageDays, date: string): UsageDay {
+  const existing = days[date]
+  if (existing !== undefined) return existing
+  const created = emptyDay()
+  days[date] = created
+  return created
+}
+
+function bump(counts: Record<string, number>, key: string, amount: number): void {
+  counts[key] = (counts[key] ?? 0) + amount
+}
+
+/** Streamed: the largest transcript here is ~90 MB, which `Bun.file().text()` would materialize whole. */
+export async function readJsonlLines(path: string, onLine: (line: string) => void): Promise<void> {
+  const decoder = new TextDecoder()
+  let carry = ''
+
+  for await (const chunk of Bun.file(path).stream()) {
+    // `stream: true` holds back a partial UTF-8 sequence at the chunk edge
+    // instead of replacing it with U+FFFD and corrupting the line.
+    const parts = (carry + decoder.decode(chunk, { stream: true })).split('\n')
+    carry = parts.pop() ?? ''
+    for (const line of parts) onLine(line)
+  }
+
+  carry += decoder.decode()
+  // No trailing newline, or a file being appended to right now — the half-written
+  // last line just fails JSON.parse downstream.
+  if (carry !== '') onLine(carry)
+}
+
+function findJsonl(root: string): string[] {
+  try {
+    // Recursive: transcripts nest at varying depths and a flat readdir misses half.
+    return readdirSync(root, { recursive: true })
+      .filter((entry): entry is string => typeof entry === 'string' && entry.endsWith('.jsonl'))
+      .map((entry) => join(root, entry))
+  } catch {
+    return [] // assistant not installed on this machine
+  }
+}
+
+async function forEachFile(paths: string[], run: (path: string) => Promise<void>): Promise<void> {
+  let cursor = 0
+  // `cursor++` needs no lock: no await between read and increment, single thread.
+  const workers = Array.from({ length: Math.min(FILE_CONCURRENCY, paths.length) }, async () => {
+    while (cursor < paths.length) {
+      const path = paths[cursor++]
+      if (path === undefined) return
+      try {
+        await run(path)
+      } catch {
+        // One unreadable transcript must never sink the whole rollup.
+      }
+    }
+  })
+  await Promise.all(workers)
+}
+
+interface TranscriptUsage {
+  cache_creation_input_tokens?: number
+  cache_read_input_tokens?: number
+  input_tokens?: number
+  output_tokens?: number
+}
+
+interface TranscriptLine {
+  gitBranch?: string
+  message?: { id?: string; model?: string; usage?: TranscriptUsage }
+  requestId?: string
+  timestamp?: string
+}
+
+/** `seen` spans the whole run: resume, fork and compaction re-emit the same billed request across files. */
+export function consumeTranscriptLine(line: string, seen: Set<string>, days: UsageDays): void {
+  // ~23k of ~126k lines carry usage; the rest hold base64 thinking blobs. A
+  // substring test beats parsing them.
+  if (!line.includes('"output_tokens"')) return
+
+  let entry: TranscriptLine
+  try {
+    entry = JSON.parse(line) as TranscriptLine
+  } catch {
+    return
+  }
+
+  const usage = entry.message?.usage
+  if (usage === undefined || entry.timestamp == null) return
+
+  // Placeholder messages (API errors, interrupted turns) carry junk usage.
+  const model = entry.message?.model
+  if (model === '<synthetic>') return
+
+  const id = entry.message?.id
+  const { requestId } = entry
+  // Both halves or nothing: without an id a duplicate cannot be proven, and
+  // undercounting a stats page is worse than a rare double.
+  if (id != null && id !== '' && requestId != null && requestId !== '') {
+    const key = `${id}:${requestId}`
+    if (seen.has(key)) return
+    seen.add(key)
+  }
+
+  const ms = Date.parse(entry.timestamp)
+  if (!Number.isFinite(ms)) return
+
+  const cacheRead = usage.cache_read_input_tokens ?? 0
+  const cacheWrite = usage.cache_creation_input_tokens ?? 0
+  const input = usage.input_tokens ?? 0
+  const output = usage.output_tokens ?? 0
+  const total = input + output + cacheRead + cacheWrite
+  if (total <= 0) return
+
+  const day = dayAt(days, localDay(new Date(ms)))
+  day.tokens.cacheRead += cacheRead
+  day.tokens.cacheWrite += cacheWrite
+  day.tokens.input += input
+  day.tokens.output += output
+  day.tokens.total += total
+
+  if (model != null && model !== '') bump(day.models, model, total)
+  const branch = entry.gitBranch
+  if (branch != null && branch !== '') bump(day.branches, branch, total)
+}
+
+/** `history.jsonl`, the prompt log — the only source that survives transcript pruning. */
+export function consumeHistoryLine(line: string, days: UsageDays): void {
+  if (!line.includes('"timestamp"')) return
+
+  let entry: { timestamp?: number | string }
+  try {
+    entry = JSON.parse(line) as { timestamp?: number | string }
+  } catch {
+    return
+  }
+
+  // A number today, quoted in past releases. `Number()` covers both, where
+  // `new Date(quoted)` returns Invalid Date and drops the entry.
+  const ms = Number(entry.timestamp)
+  if (!Number.isFinite(ms) || ms <= 0) return
+
+  dayAt(days, localDay(new Date(ms))).prompts += 1
+}
+
+interface CodexLine {
+  payload?: {
+    info?: {
+      last_token_usage?: {
+        cached_input_tokens?: number
+        input_tokens?: number
+        output_tokens?: number
+        total_tokens?: number
+      }
+    }
+    model?: string
+  }
+  timestamp?: string
+}
+
+export interface CodexFileState {
+  model: string | null
+}
+
+/** `last_token_usage` is the per-turn delta; the sibling `total_token_usage` is cumulative — summing it overcounts by n²/2. */
+export function consumeCodexLine(line: string, state: CodexFileState, days: UsageDays): void {
+  if (!line.includes('"model"') && !line.includes('"last_token_usage"')) return
+
+  let entry: CodexLine
+  try {
+    entry = JSON.parse(line) as CodexLine
+  } catch {
+    return
+  }
+
+  const model = entry.payload?.model
+  if (model != null && model !== '') state.model = model
+
+  const usage = entry.payload?.info?.last_token_usage
+  if (usage === undefined || entry.timestamp == null) return
+
+  const ms = Date.parse(entry.timestamp)
+  if (!Number.isFinite(ms)) return
+
+  const cacheRead = usage.cached_input_tokens ?? 0
+  const total = usage.total_tokens ?? 0
+  if (total <= 0) return
+
+  const day = dayAt(days, localDay(new Date(ms)))
+  day.tokens.cacheRead += cacheRead
+  // cached_input_tokens ⊂ input_tokens, so the cached share is subtracted not added.
+  day.tokens.input += Math.max(0, (usage.input_tokens ?? 0) - cacheRead)
+  day.tokens.output += usage.output_tokens ?? 0
+  day.tokens.total += total
+
+  if (state.model != null && state.model !== '') bump(day.models, state.model, total)
+}
+
+async function collectClaude(): Promise<UsageDays> {
+  const days: UsageDays = {}
+  const seen = new Set<string>()
+  const root = claudeHome()
+
+  await forEachFile(findJsonl(join(root, 'projects')), async (path) => {
+    await readJsonlLines(path, (line) => {
+      consumeTranscriptLine(line, seen, days)
+    })
+  })
+
+  try {
+    await readJsonlLines(join(root, 'history.jsonl'), (line) => {
+      consumeHistoryLine(line, days)
+    })
+  } catch {
+    // No prompt log: the heatmap falls back to whatever the transcripts cover.
+  }
+
+  return days
+}
+
+async function collectCodex(): Promise<UsageDays> {
+  const days: UsageDays = {}
+
+  await forEachFile(findJsonl(join(codexHome(), 'sessions')), async (path) => {
+    const state: CodexFileState = { model: null }
+    await readJsonlLines(path, (line) => {
+      consumeCodexLine(line, state, days)
+    })
+  })
+
+  return days
+}
+
+export async function runUsageRollup(): Promise<number> {
+  try {
+    const [claude, codex] = await Promise.all([collectClaude(), collectCodex()])
+
+    const fresh: UsageTools = {}
+    if (Object.keys(claude).length > 0) fresh.claude = claude
+    if (Object.keys(codex).length > 0) fresh.codex = codex
+
+    // Nothing parsed means every source was missing. Writing would bump the
+    // mtime, which schedules the next run, and buy a day of not retrying.
+    if (Object.keys(fresh).length === 0) {
+      logDebug('usageHistory.rollupEmpty', {})
+      return 1
+    }
+
+    return saveUsageHistory(fresh) ? 0 : 1
+  } catch (error) {
+    logDebug('usageHistory.rollupError', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return 1
+  }
+}