@brimveyn/aimux 1.7.3 → 1.8.0

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

@@ -0,0 +1,191 @@
+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 } from '../types'
+
+interface CodexAuthFile {
+  tokens?: {
+    access_token?: string
+    account_id?: string
+  }
+}
+
+interface WindowSnapshot {
+  used_percent?: number
+  reset_at?: number
+  limit_window_seconds?: number
+}
+
+interface CodexUsageResponse {
+  plan_type?: string
+  rate_limit?: {
+    primary_window?: WindowSnapshot | null
+    secondary_window?: WindowSnapshot | null
+  }
+  credits?: {
+    has_credits?: boolean
+    unlimited?: boolean
+    balance?: number | string | null
+  }
+}
+
+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) 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() ?? ''
+    if (!line) continue
+    const eq = line.indexOf('=')
+    if (eq < 0) continue
+    const key = line.slice(0, eq).trim()
+    if (key !== 'chatgpt_base_url') continue
+    let value = line.slice(eq + 1).trim()
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    return value.trim()
+  }
+  return null
+}
+
+function normalizeBase(value: string): string {
+  let trimmed = value.trim() || DEFAULT_CHATGPT_BASE
+  while (trimmed.endsWith('/')) trimmed = trimmed.slice(0, -1)
+  if (
+    (trimmed.startsWith('https://chatgpt.com') || trimmed.startsWith('https://chat.openai.com')) &&
+    !trimmed.includes('/backend-api')
+  ) {
+    trimmed += '/backend-api'
+  }
+  return trimmed
+}
+
+async function resolveUsageURL(): Promise<string> {
+  let base = DEFAULT_CHATGPT_BASE
+  try {
+    const contents = await readFile(join(codexHome(), 'config.toml'), 'utf8')
+    const parsed = parseChatGPTBaseFromConfig(contents)
+    if (parsed) base = parsed
+  } catch {
+    // no config.toml or unreadable — fall back to default
+  }
+  const normalized = normalizeBase(base)
+  const path = normalized.includes('/backend-api') ? USAGE_PATH : '/api/codex/usage'
+  return normalized + path
+}
+
+async function loadAuth(): Promise<{ accessToken: string; accountId: string | null }> {
+  const raw = await readFile(join(codexHome(), 'auth.json'), 'utf8')
+  const parsed = JSON.parse(raw) as CodexAuthFile
+  const accessToken = parsed.tokens?.access_token
+  if (!accessToken) {
+    throw new Error('no access_token in ~/.codex/auth.json — run `codex` to sign in')
+  }
+  return {
+    accessToken,
+    accountId: parsed.tokens?.account_id ?? null,
+  }
+}
+
+function formatRemainingFromReset(resetAtSeconds: number | undefined): string | null {
+  if (!resetAtSeconds) return null
+  const diffMs = resetAtSeconds * 1000 - Date.now()
+  if (diffMs <= 0) return null
+  const totalMin = Math.round(diffMs / 60_000)
+  const h = Math.floor(totalMin / 60)
+  const m = totalMin % 60
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}h`
+}
+
+function pickPrimaryWindow(rate: CodexUsageResponse['rate_limit']): WindowSnapshot | null {
+  if (!rate) return null
+  // Primary = 5h session window. Pick the one closest to 300 minutes (18000s),
+  // falling back to whichever is defined.
+  const windows = [rate.primary_window, rate.secondary_window].filter(
+    (w): w is WindowSnapshot => !!w
+  )
+  if (windows.length === 0) return null
+  const sessionWindow = windows.find((w) => w.limit_window_seconds === 18_000)
+  return sessionWindow ?? windows[0] ?? null
+}
+
+export async function fetchCodexUsage(_config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  const now = new Date().toISOString()
+  const base: UsageSnapshot = {
+    burnRatePerHour: null,
+    costUSD: null,
+    lastUpdated: now,
+    percent: null,
+    resetAt: null,
+    timeRemaining: null,
+    tokens: { cache: 0, input: 0, output: 0, total: 0 },
+    tool: 'codex',
+  }
+
+  try {
+    const { accessToken, accountId } = await loadAuth()
+    const url = await resolveUsageURL()
+
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+      'Authorization': `Bearer ${accessToken}`,
+      'User-Agent': 'aimux',
+    }
+    if (accountId) headers['ChatGPT-Account-Id'] = accountId
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), AUTH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(url, { headers, signal: controller.signal })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      return { ...base, error: 'codex oauth expired — run `codex` to re-auth' }
+    }
+    if (!response.ok) {
+      return { ...base, error: `codex api ${response.status}` }
+    }
+
+    const parsed = (await response.json()) as CodexUsageResponse
+    const window = pickPrimaryWindow(parsed.rate_limit)
+    if (!window) {
+      return { ...base, error: 'no rate_limit data' }
+    }
+
+    const percent =
+      typeof window.used_percent === 'number'
+        ? Math.max(0, Math.min(100, window.used_percent))
+        : null
+    const resetAt = window.reset_at ? new Date(window.reset_at * 1000).toISOString() : null
+
+    return {
+      ...base,
+      percent,
+      resetAt,
+      timeRemaining: formatRemainingFromReset(window.reset_at),
+      tool: 'codex',
+    }
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}

package/src/services/ai-usage/provider.ts

@@ -0,0 +1,84 @@
+import type { AIUsageTool, AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import type { UsageSnapshot } from './types'
+
+import { fetchClaudeUsage } from './adapters/claude'
+import { fetchCodexUsage } from './adapters/codex'
+
+const DEFAULT_POLL_SECONDS = 60
+const DEFAULT_TOOLS: AIUsageTool[] = ['claude', 'codex']
+
+export interface AIUsageServiceHandle {
+  stop: () => void
+  refresh: () => void
+}
+
+async function fetchFor(tool: AIUsageTool, config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  switch (tool) {
+    case 'claude':
+      return fetchClaudeUsage(config)
+    case 'codex':
+      return fetchCodexUsage(config)
+  }
+}
+
+export function startAIUsageService(
+  config: AIUsageToolConfig,
+  onUpdate: (snap: UsageSnapshot) => void
+): AIUsageServiceHandle {
+  const tools = config.tools && config.tools.length > 0 ? config.tools : DEFAULT_TOOLS
+  const pollMs = Math.max(5, config.pollSeconds ?? DEFAULT_POLL_SECONDS) * 1000
+
+  let stopped = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  const tick = async (): Promise<void> => {
+    if (stopped) return
+    const results = await Promise.allSettled(tools.map((t) => fetchFor(t, config)))
+    if (stopped) return
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]
+      const tool = tools[i]
+      if (!result || !tool) continue
+      if (result.status === 'fulfilled') {
+        onUpdate(result.value)
+      } else {
+        onUpdate({
+          burnRatePerHour: null,
+          costUSD: null,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+          lastUpdated: new Date().toISOString(),
+          percent: null,
+          resetAt: null,
+          timeRemaining: null,
+          tokens: { cache: 0, input: 0, output: 0, total: 0 },
+          tool,
+        })
+      }
+    }
+    if (!stopped) {
+      timer = setTimeout(() => {
+        void tick()
+      }, pollMs)
+    }
+  }
+
+  void tick()
+
+  return {
+    refresh: () => {
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+      void tick()
+    },
+    stop: () => {
+      stopped = true
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+    },
+  }
+}

package/src/services/ai-usage/spawn.ts

@@ -0,0 +1,49 @@
+interface CliResult {
+  ok: boolean
+  stdout: string
+  stderr: string
+  error?: string
+}
+
+const DEFAULT_TIMEOUT_MS = 15_000
+
+export async function runCli(
+  command: string,
+  args: string[],
+  timeoutMs: number = DEFAULT_TIMEOUT_MS
+): Promise<CliResult> {
+  const proc = Bun.spawn([command, ...args], {
+    stderr: 'pipe',
+    stdin: 'ignore',
+    stdout: 'pipe',
+  })
+
+  const timeout = setTimeout(() => {
+    try {
+      proc.kill()
+    } catch {
+      // process already gone
+    }
+  }, timeoutMs)
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+
+    if (exitCode !== 0) {
+      return {
+        error: `${command} exit ${exitCode}: ${stderr.trim().slice(0, 200)}`,
+        ok: false,
+        stderr,
+        stdout,
+      }
+    }
+
+    return { ok: true, stderr, stdout }
+  } finally {
+    clearTimeout(timeout)
+  }
+}

package/src/services/ai-usage/types.ts

@@ -0,0 +1,20 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+export type { AIUsageTool }
+
+export interface UsageSnapshot {
+  tool: AIUsageTool
+  percent: number | null
+  tokens: {
+    input: number
+    output: number
+    cache: number
+    total: number
+  }
+  costUSD: number | null
+  resetAt: string | null
+  timeRemaining: string | null
+  burnRatePerHour: number | null
+  lastUpdated: string
+  error?: string
+}

package/src/session-backend/local-session-backend.ts

@@ -12,6 +12,7 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
+import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
@@ -66,15 +67,22 @@ export class LocalSessionBackend
     })
     this.currentSessionId = options.sessionId
     const trees = getSnapshotTrees(options.workspaceSnapshot)
+    const intents = getSnapshotScrollIntents(options.workspaceSnapshot)
     const splitTrees = trees.filter((t) => t.type === 'split')
     if (splitTrees.length > 0) {
       const bounds = createTerminalBounds(options.cols, options.rows)
       forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
         const size = toTerminalContentSize(rect)
-        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
+        this.sessionManager.resizeTab(
+          options.sessionId,
+          tabId,
+          size.cols,
+          size.rows,
+          intents.get(tabId)
+        )
       })
     } else {
-      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
+      this.sessionManager.resize(options.sessionId, options.cols, options.rows, intents)
     }
     const attachResult = this.sessionManager.attachSession(
       options.sessionId,

package/src/state/ai-usage-store.ts

@@ -0,0 +1,29 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { UsageSnapshot } from '../services/ai-usage/types'
+
+export interface AIUsageState {
+  enabled: boolean
+  snapshots: Partial<Record<AIUsageTool, UsageSnapshot>>
+  setEnabled: (enabled: boolean) => void
+  setSnapshot: (snap: UsageSnapshot) => void
+  clear: () => void
+}
+
+export const aiUsageStore = createStore<AIUsageState>((set) => ({
+  clear: () => set({ snapshots: {} }),
+  enabled: false,
+  setEnabled: (enabled: boolean) => set({ enabled }),
+  setSnapshot: (snap: UsageSnapshot) =>
+    set((state) => ({
+      snapshots: { ...state.snapshots, [snap.tool]: snap },
+    })),
+  snapshots: {},
+}))
+
+export function useAIUsageStore<T>(selector: (state: AIUsageState) => T): T {
+  return useStore(aiUsageStore, selector)
+}

package/src/state/git-pane-sizing.ts

@@ -0,0 +1,15 @@
+export const GIT_PANE_MIN_RATIO = 0.2
+export const GIT_PANE_MAX_RATIO = 0.8
+export const GIT_PANE_MIN_WIDTH = 20
+export const GIT_PANE_MAX_WIDTH = 80
+
+export function clampGitPaneRatio(value: number): number {
+  return Math.max(GIT_PANE_MIN_RATIO, Math.min(GIT_PANE_MAX_RATIO, value))
+}
+
+export function getGitPaneWidthFromRatio(ratio: number): number {
+  return Math.max(
+    GIT_PANE_MIN_WIDTH,
+    Math.min(GIT_PANE_MAX_WIDTH, Math.round(clampGitPaneRatio(ratio) * GIT_PANE_MAX_WIDTH))
+  )
+}

package/src/state/reducers/auto-commit-state.ts

@@ -0,0 +1,59 @@
+import type { AppAction, AppState, AutoCommitState } from '../types'
+
+function setBySession(
+  state: AutoCommitState,
+  sessionId: string,
+  next: AutoCommitState['bySession'][string]
+): AutoCommitState {
+  return { bySession: { ...state.bySession, [sessionId]: next } }
+}
+
+export function reduceAutoCommitState(
+  state: AutoCommitState,
+  action: AppAction
+): AutoCommitState | null {
+  switch (action.type) {
+    case 'auto-commit-generation-started': {
+      return setBySession(state, action.sessionId, {
+        abortController: action.abortController,
+        kind: 'generating',
+        startedAt: action.startedAt,
+        tabId: action.tabId,
+        workingTreeHash: action.workingTreeHash,
+      })
+    }
+    case 'auto-commit-generation-ready': {
+      const current = state.bySession[action.sessionId]
+      if (!current || current.kind !== 'generating') return null
+      if (current.workingTreeHash !== action.workingTreeHash) return null
+      return setBySession(state, action.sessionId, {
+        body: action.body,
+        generatedAt: action.generatedAt,
+        kind: 'ready',
+        tabId: current.tabId,
+        title: action.title,
+        workingTreeHash: current.workingTreeHash,
+      })
+    }
+    case 'auto-commit-clear': {
+      const current = state.bySession[action.sessionId]
+      if (!current || current.kind === 'idle') return null
+      if (current.kind === 'generating') {
+        try {
+          current.abortController.abort()
+        } catch {
+          // ignore
+        }
+      }
+      return setBySession(state, action.sessionId, { kind: 'idle' })
+    }
+    default:
+      return null
+  }
+}
+
+export function reduceAutoCommit(state: AppState, action: AppAction): AppState | null {
+  const next = reduceAutoCommitState(state.autoCommit, action)
+  if (next === null) return null
+  return { ...state, autoCommit: next }
+}

package/src/state/reducers/git-panel-state.ts

@@ -1,11 +1,9 @@
 import type { AppAction, AppState, GitFileEntry, GitFileSection, GitPanelState } from '../types'
 
+import { clampGitPaneRatio } from '../git-pane-sizing'
 import { reconcileSelectedGitEntryKey } from '../git-tree'
 import { clearDiffCacheForPaths } from './diff-cache'
 
-export const GIT_PANEL_MIN_RATIO = 0.2
-export const GIT_PANEL_MAX_RATIO = 0.8
-
 const SECTION_RANK: Record<GitFileSection, number> = {
   historical: 0,
   staged: 1,
@@ -23,7 +21,7 @@ export function sortFilesBySection(files: GitFileEntry[]): GitFileEntry[] {
 }
 
 function clampRatio(value: number): number {
-  return Math.max(GIT_PANEL_MIN_RATIO, Math.min(GIT_PANEL_MAX_RATIO, value))
+  return clampGitPaneRatio(value)
 }
 
 export function emptyGitPanel(): GitPanelState {
@@ -93,9 +91,16 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
       }
     }
     case 'resize-git-pane': {
-      const nextRatio = clampRatio(state.gitPane.ratio + action.delta)
-      if (nextRatio === state.gitPane.ratio) return state
-      return { ...state, gitPane: { ...state.gitPane, ratio: nextRatio } }
+      const target = state.gitPane.mode === 'pane' ? 'paneRatio' : 'embeddedRatio'
+      const nextRatio = clampRatio(state.gitPane[target] + action.delta)
+      if (nextRatio === state.gitPane[target]) return state
+      return { ...state, gitPane: { ...state.gitPane, [target]: nextRatio } }
+    }
+    case 'set-git-pane-ratio': {
+      const key = action.target === 'pane' ? 'paneRatio' : 'embeddedRatio'
+      const nextRatio = clampRatio(action.ratio)
+      if (nextRatio === state.gitPane[key]) return state
+      return { ...state, gitPane: { ...state.gitPane, [key]: nextRatio } }
     }
     case 'resize-git-diff-pane': {
       const nextRatio = clampRatio(state.gitPane.diffModeRatio + action.delta)

package/src/state/reducers/modal-state.ts

@@ -7,6 +7,7 @@ import { getActiveKeymap } from '../../input/keymap/keymap-ref'
 import { getAllAssistantOptions } from '../../pty/command-registry'
 import { filterThemeIds } from '../../ui/filter-themes'
 import { filterAssistants, filterSessions, filterSnippets } from '../selectors'
+import { reduceAutoCommitState } from './auto-commit-state'
 
 function emptyModal() {
   return {
@@ -199,7 +200,8 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           type: 'update-available',
         },
       }
-    case 'open-git-commit-modal':
+    case 'open-git-commit-modal': {
+      const sessionId = action.sessionId
       return {
         ...state,
         focusMode: 'command-edit',
@@ -209,10 +211,112 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           cursorPos: 0,
           editBuffer: '',
           selectedIndex: 0,
-          sessionTargetId: null,
+          sessionTargetId: sessionId ?? null,
+          stage: 'edit',
           type: 'git-commit',
         },
       }
+    }
+    case 'git-commit-enter-confirm': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'confirm' },
+      }
+    }
+    case 'git-commit-leave-confirm': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
+    case 'git-commit-enter-generating': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'modal',
+        modal: { ...state.modal, sessionTargetId: action.sessionId, stage: 'generating' },
+      }
+    }
+    case 'git-commit-leave-generating': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
+    case 'auto-commit-generation-ready': {
+      if (
+        state.modal.type !== 'git-commit' ||
+        state.modal.stage !== 'generating' ||
+        state.modal.sessionTargetId !== action.sessionId
+      ) {
+        return null
+      }
+      const nextAutoCommit = reduceAutoCommitState(state.autoCommit, action)
+      if (!nextAutoCommit) {
+        // Stale result (hash mismatch or slice was cleared mid-flight): don't
+        // strand the modal in `generating` — flip back to edit so the user
+        // isn't stuck staring at a spinner that will never resolve.
+        return {
+          ...state,
+          focusMode: 'command-edit',
+          modal: { ...state.modal, stage: 'edit' },
+        }
+      }
+      return {
+        ...state,
+        autoCommit: nextAutoCommit,
+        focusMode: 'command-edit',
+        modal: {
+          ...state.modal,
+          activeField: 'title',
+          contentBuffer: action.body,
+          cursorPos: action.title.length,
+          editBuffer: action.title,
+          stage: 'confirm',
+        },
+      }
+    }
+    case 'git-commit-use-background-suggestion': {
+      if (state.modal.type !== 'git-commit' || state.modal.sessionTargetId !== action.sessionId) {
+        return null
+      }
+      const suggestion = state.autoCommit.bySession[action.sessionId]
+      if (!suggestion || suggestion.kind !== 'ready') return null
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: {
+          ...state.modal,
+          activeField: 'title',
+          contentBuffer: suggestion.body,
+          cursorPos: suggestion.title.length,
+          editBuffer: suggestion.title,
+          stage: 'confirm',
+        },
+      }
+    }
+    case 'auto-commit-clear': {
+      if (
+        state.modal.type !== 'git-commit' ||
+        state.modal.stage !== 'generating' ||
+        state.modal.sessionTargetId !== action.sessionId
+      ) {
+        return null
+      }
+      const nextAutoCommit = reduceAutoCommitState(state.autoCommit, action)
+      return {
+        ...state,
+        autoCommit: nextAutoCommit ?? state.autoCommit,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
     case 'set-help-entry-count': {
       if (state.modal.type !== 'help') return state
       if (state.modal.entryCount === action.count) {