@tduyng/pi-cost 0.0.0-stage → 0.0.2

package/src/cost/logic.ts

@@ -0,0 +1,513 @@
+import fs from 'node:fs/promises'
+import { createReadStream } from 'node:fs'
+import { createInterface } from 'node:readline'
+import path from 'node:path'
+import type { JsonObject, JsonValue } from '@earendil-works/pi-ai'
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+const JsonRecord = t.object({}, { additionalProperties: true })
+const isJsonRecord = new Validator(JsonRecord).isValidObject
+const JsonArray = t.array(t.unknown())
+const isJsonArray = new Validator(JsonArray).isValidObject
+const NonemptyString = t.string({ minLength: 1 })
+const isNonemptyString = new Validator(NonemptyString).isValidObject
+const TimestampString = t.string()
+const isTimestampString = new Validator(TimestampString).isValidObject
+const TimestampNumber = t.number()
+const isTimestampNumber = new Validator(TimestampNumber).isValidObject
+
+function isRecord<T>(value: T): value is T & JsonObject {
+    return isJsonRecord(value)
+}
+
+function isArray<T>(value: T): value is T & JsonValue[] {
+    return isJsonArray(value)
+}
+
+export interface LimitRow {
+    label: string
+    percent?: number
+    resetAt?: number
+    detail?: string
+}
+
+export interface TokenTotals {
+    input: number
+    output: number
+    cacheRead: number
+    cacheWrite: number
+}
+
+export interface SessionTotals extends TokenTotals {
+    turns: number
+    wallMs: number
+}
+
+export interface ProviderTokenRow extends TokenTotals {
+    provider: string
+    window: string
+    costUsd: number
+}
+
+export interface UsageRecord extends TokenTotals {
+    provider: string
+    at: number
+    costUsd: number
+}
+
+export interface AnthropicWindow {
+    utilization?: number | null
+    resets_at?: string | number | null
+}
+
+export interface AnthropicUsagePayload {
+    five_hour?: AnthropicWindow | null
+    seven_day?: AnthropicWindow | null
+    seven_day_opus?: AnthropicWindow | null
+    seven_day_sonnet?: AnthropicWindow | null
+}
+
+export interface OpenCodeUsagePayload {
+    usage?: {
+        rolling?: { status?: string | null; percent?: number | null; resetsAt?: string | null } | null
+        weekly?: { status?: string | null; percent?: number | null; resetsAt?: string | null } | null
+        monthly?: { status?: string | null; percent?: number | null; resetsAt?: string | null } | null
+    } | null
+}
+
+export interface CommandCodeWindow {
+    used?: number | null
+    cap?: number | null
+    resetAt?: string | number | null
+}
+
+export interface CommandCodeCreditsPayload {
+    credits?: {
+        monthlyCredits?: number | null
+        purchasedCredits?: number | null
+        freeCredits?: number | null
+    } | null
+    windowLimits?: {
+        fiveHour?: CommandCodeWindow | null
+        weekly?: CommandCodeWindow | null
+    } | null
+}
+
+function finite(value: number | null | undefined): number | undefined {
+    const numeric = value ?? Number.NaN
+    return Number.isFinite(numeric) ? numeric : undefined
+}
+
+export function resetAtMs(value: string | number | null | undefined): number | undefined {
+    if (value === null || value === undefined) return undefined
+    let parsed: number
+    if (isTimestampNumber(value)) {
+        parsed = value
+    } else if (isTimestampString(value)) {
+        const text = value.trim()
+        parsed = /^\d+$/.test(text) ? Number(text) : Date.parse(text)
+    } else {
+        return undefined
+    }
+    if (!Number.isFinite(parsed) || parsed <= 0) return undefined
+    return parsed < 1e12 ? parsed * 1000 : parsed
+}
+
+interface ClaudeCredentialsBlob {
+    claudeAiOauth?: { accessToken?: string }
+}
+
+export function claudeAccessToken(raw: string | undefined): string | undefined {
+    if (!raw) return undefined
+    let parsed: ClaudeCredentialsBlob
+    try {
+        parsed = JSON.parse(raw) as ClaudeCredentialsBlob
+    } catch {
+        return undefined
+    }
+    if (!parsed || !isRecord(parsed)) return undefined
+    const oauth = parsed['claudeAiOauth']
+    if (!isRecord(oauth)) return undefined
+    const token = oauth['accessToken']
+    return isNonemptyString(token) ? token : undefined
+}
+
+function dollars(used: number | undefined, limit: number | undefined): string | undefined {
+    return used !== undefined && limit !== undefined ? `$${used.toFixed(2)} / $${limit.toFixed(2)}` : undefined
+}
+
+export function exhaustedResetAt(payload: AnthropicUsagePayload): number | undefined {
+    const windows = [payload.five_hour, payload.seven_day, payload.seven_day_opus, payload.seven_day_sonnet]
+
+    let latest: number | undefined
+    for (const window of windows) {
+        const utilization = finite(window?.utilization)
+        const resetAt = resetAtMs(window?.resets_at)
+
+        if (utilization === undefined || utilization < 100 || resetAt === undefined) continue
+        latest = latest === undefined ? resetAt : Math.max(latest, resetAt)
+    }
+
+    return latest
+}
+
+export function commandCodeRows(payload: CommandCodeCreditsPayload): LimitRow[] {
+    const rows: LimitRow[] = []
+    const windows = [
+        ['Session (5h)', payload.windowLimits?.fiveHour],
+        ['Week', payload.windowLimits?.weekly]
+    ] as const
+    for (const [label, window] of windows) {
+        const used = finite(window?.used)
+        const cap = finite(window?.cap)
+        if (used === undefined || cap === undefined || cap <= 0) continue
+        rows.push({
+            label,
+            percent: (used / cap) * 100,
+            resetAt: resetAtMs(window?.resetAt),
+            detail: dollars(used, cap)
+        })
+    }
+    const credits = payload.credits
+    if (credits) {
+        const remaining =
+            (finite(credits.monthlyCredits) ?? 0) +
+            (finite(credits.purchasedCredits) ?? 0) +
+            (finite(credits.freeCredits) ?? 0)
+        rows.push({ label: 'Credits left', detail: `$${remaining.toFixed(2)}` })
+    }
+    return rows
+}
+
+export function openCodeRows(payload: OpenCodeUsagePayload): LimitRow[] {
+    const rows: LimitRow[] = []
+    const windows = [
+        ['Session (5h)', payload.usage?.rolling],
+        ['Week', payload.usage?.weekly],
+        ['Month', payload.usage?.monthly]
+    ] as const
+    for (const [label, window] of windows) {
+        const percent = finite(window?.percent)
+        if (percent === undefined) continue
+        rows.push({ label, percent, resetAt: resetAtMs(window?.resetsAt) })
+    }
+    return rows
+}
+
+export function anthropicRows(payload: AnthropicUsagePayload): LimitRow[] {
+    const rows: LimitRow[] = []
+    const windows = [
+        ['Session (5h)', payload.five_hour],
+        ['Week', payload.seven_day],
+        ['Week (Opus)', payload.seven_day_opus],
+        ['Week (Sonnet)', payload.seven_day_sonnet]
+    ] as const
+    for (const [label, window] of windows) {
+        const percent = finite(window?.utilization)
+        if (percent === undefined) continue
+        rows.push({ label, percent, resetAt: resetAtMs(window?.resets_at) })
+    }
+    return rows
+}
+
+const BAR_WIDTH = 24
+
+export function bar(percent: number): string {
+    const clamped = Math.max(0, Math.min(100, percent))
+    const filled = Math.round((clamped / 100) * BAR_WIDTH)
+    return '█'.repeat(filled) + '·'.repeat(BAR_WIDTH - filled)
+}
+
+export function formatReset(resetAt: number | undefined, now = Date.now()): string | undefined {
+    if (resetAt === undefined || resetAt <= now) return undefined
+    const date = new Date(resetAt)
+    const time = date.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' })
+    if (new Date(now).toDateString() === date.toDateString()) return `resets ${time}`
+    return `resets ${date.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })} at ${time}`
+}
+
+export function formatTokens(tokens: number): string {
+    if (tokens >= 1_000_000_000) return `${(tokens / 1_000_000_000).toFixed(1)}B`
+    if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`
+    if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}k`
+    return String(tokens)
+}
+
+export function formatTokenCell(tokens: number): string {
+    return tokens === 0 ? '·' : formatTokens(tokens)
+}
+
+export function formatCacheHit(totals: TokenTotals): string | undefined {
+    const prompt = totals.input + totals.cacheRead + totals.cacheWrite
+    if (prompt === 0) return undefined
+    return `${Math.round((totals.cacheRead / prompt) * 100)}%`
+}
+
+export function formatDuration(ms: number): string {
+    const totalMinutes = Math.floor(ms / 60_000)
+    const hours = Math.floor(totalMinutes / 60)
+    if (hours > 0) return `${hours}h ${totalMinutes % 60}m`
+    if (totalMinutes > 0) return `${totalMinutes}m`
+    return `${Math.round(ms / 1000)}s`
+}
+
+export interface SessionTurn {
+    usage: { input: number; output: number; cacheRead: number; cacheWrite: number } | undefined
+    timestamp: string
+}
+
+export function sessionTotals(turns: SessionTurn[], now = Date.now()): SessionTotals {
+    const totals: SessionTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, turns: 0, wallMs: 0 }
+    let firstMs: number | undefined
+    for (const turn of turns) {
+        const started = Date.parse(turn.timestamp)
+        if (Number.isFinite(started) && (firstMs === undefined || started < firstMs)) firstMs = started
+        if (!turn.usage) continue
+        totals.input += turn.usage.input
+        totals.output += turn.usage.output
+        totals.cacheRead += turn.usage.cacheRead
+        totals.cacheWrite += turn.usage.cacheWrite
+        totals.turns += 1
+    }
+    if (firstMs !== undefined) totals.wallMs = Math.max(0, now - firstMs)
+    return totals
+}
+
+interface RawSessionLine {
+    type?: string
+    timestamp?: string
+    message?: {
+        role?: string
+        provider?: string
+        timestamp?: number
+        usage?: {
+            input?: number
+            output?: number
+            cacheRead?: number
+            cacheWrite?: number
+            cost?: { total?: number | null }
+        }
+    }
+}
+
+export function parseUsageLine(line: string): UsageRecord | undefined {
+    if (!line.includes('"usage"')) return undefined
+    let entry: RawSessionLine
+    try {
+        entry = JSON.parse(line) as RawSessionLine
+    } catch {
+        return undefined
+    }
+    const usage = entry.message?.usage
+    if (entry.type !== 'message' || entry.message?.role !== 'assistant' || !usage) return undefined
+    const at = resetAtMs(entry.message.timestamp ?? entry.timestamp)
+    if (at === undefined) return undefined
+    return {
+        provider: entry.message.provider ?? 'unknown',
+        at,
+        costUsd: Math.max(0, finite(usage.cost?.total) ?? 0),
+        input: usage.input ?? 0,
+        output: usage.output ?? 0,
+        cacheRead: usage.cacheRead ?? 0,
+        cacheWrite: usage.cacheWrite ?? 0
+    }
+}
+
+export function monthStart(now: number): number {
+    const date = new Date(now)
+    return new Date(date.getFullYear(), date.getMonth(), 1).getTime()
+}
+
+const TOKEN_WINDOWS = [
+    ['5h', (now: number) => now - 5 * 3_600_000],
+    ['7d', (now: number) => now - 7 * 86_400_000],
+    ['30d', (now: number) => now - 30 * 86_400_000],
+    ['month', monthStart]
+] as const
+
+export function tokenScanSince(now = Date.now()): number {
+    return Math.min(...TOKEN_WINDOWS.map(([, start]) => start(now)))
+}
+
+export function totalTokens(totals: TokenTotals): number {
+    return totals.input + totals.output + totals.cacheRead + totals.cacheWrite
+}
+
+export interface CachedFile {
+    mtimeMs: number
+    size: number
+    records: UsageRecord[]
+}
+
+export interface CachedQuota {
+    rows: LimitRow[]
+    fetchedAt: number
+}
+
+export interface CostCache {
+    quota: Record<string, CachedQuota>
+    files: Record<string, CachedFile>
+}
+
+const CACHE_VERSION = 2
+
+export const MAX_COST_CACHE_BYTES = 8 * 1024 * 1024
+
+export const QUOTA_STALE_MS = 24 * 3_600_000
+
+export function cachedQuota(cache: CostCache, provider: string, now = Date.now()): CachedQuota | undefined {
+    const cached = cache.quota[provider]
+    return cached && now - cached.fetchedAt <= QUOTA_STALE_MS ? cached : undefined
+}
+
+export function cachedRecords(cache: CostCache, since: number): UsageRecord[] {
+    return Object.values(cache.files).flatMap((entry) => {
+        if (!entry || !Array.isArray(entry.records)) return []
+        return entry.records.filter((record) => record != null && record.at >= since)
+    })
+}
+
+export function emptyCostCache(): CostCache {
+    return { quota: {}, files: {} }
+}
+
+export async function readCostCache(file: string): Promise<CostCache> {
+    const stat = await fs.stat(file).catch(() => undefined)
+    if (!stat || stat.size > MAX_COST_CACHE_BYTES) return emptyCostCache()
+    const raw = await fs.readFile(file, 'utf8').catch(() => undefined)
+    if (raw === undefined) return emptyCostCache()
+    try {
+        const parsed = JSON.parse(raw) as Partial<CostCache> & { version?: number }
+        if (parsed.version !== CACHE_VERSION) return emptyCostCache()
+        return { quota: parsed.quota ?? {}, files: parsed.files ?? {} }
+    } catch {
+        return emptyCostCache()
+    }
+}
+
+/**
+ * The cache is the one artefact here that outlives the command that wrote it, and
+ * `/cost` reads provider API keys to ask each provider for a usage window. Nothing
+ * puts those keys in a row today, so the writer is where the property is made true
+ * rather than left to every caller staying careful.
+ */
+const SECRET_KEY = /^(?:access_?token|api_?key|authorization|token|secret)$/i
+const SECRET_VALUE = /\b(?:sk-ant-[A-Za-z0-9_-]{8,}|Bearer\s+[A-Za-z0-9._~+/-]{12,})/g
+
+export function redactSecrets<T>(value: T): T {
+    if (isNonemptyString(value)) return value.replace(SECRET_VALUE, '[redacted]') as T
+    if (isArray(value)) return value.map((entry) => redactSecrets(entry)) as T
+    if (!isRecord(value)) return value
+    return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, SECRET_KEY.test(key) ? '[redacted]' : redactSecrets(entry)])
+    ) as T
+}
+
+async function replaceFile(file: string, serialized: string): Promise<void> {
+    const temporary = `${file}.${process.pid}.tmp`
+    await fs.writeFile(temporary, serialized)
+    await fs.rename(temporary, file)
+}
+
+export async function writeCostCache(file: string, cache: CostCache): Promise<void> {
+    let payload = { version: CACHE_VERSION, ...redactSecrets(cache) }
+    let serialized = JSON.stringify(payload)
+    if (Buffer.byteLength(serialized) <= MAX_COST_CACHE_BYTES) {
+        await replaceFile(file, serialized).catch(() => {})
+        return
+    }
+
+    const files = Object.entries(cache.files).toSorted((a, b) => b[1].mtimeMs - a[1].mtimeMs)
+    for (const [name] of files) {
+        delete payload.files[name]
+        serialized = JSON.stringify(payload)
+        if (Buffer.byteLength(serialized) <= MAX_COST_CACHE_BYTES) break
+    }
+    if (Buffer.byteLength(serialized) <= MAX_COST_CACHE_BYTES) {
+        await replaceFile(file, serialized).catch(() => {})
+    }
+}
+
+async function fileRecords(file: string, since: number): Promise<UsageRecord[]> {
+    const input = createReadStream(file, { encoding: 'utf8' })
+    const lines = createInterface({ input, crlfDelay: Infinity })
+    const records: UsageRecord[] = []
+    try {
+        for await (const line of lines) {
+            const record = parseUsageLine(line)
+            if (record && record.at >= since) records.push(record)
+        }
+        return records
+    } catch {
+        return []
+    } finally {
+        lines.close()
+        input.destroy()
+    }
+}
+
+export async function scanUsage(roots: readonly string[], since: number, cache: CostCache): Promise<UsageRecord[]> {
+    const files: Record<string, CachedFile> = {}
+    const records: UsageRecord[] = []
+    for (const root of roots) {
+        const names = await fs.readdir(root, { recursive: true }).catch(() => [])
+        for (const name of names) {
+            if (!name.endsWith('.jsonl')) continue
+            const file = path.join(root, name)
+            const stat = await fs.stat(file).catch(() => undefined)
+            if (!stat || stat.mtimeMs < since) continue
+            const cached = cache.files[file]
+            const entry: CachedFile =
+                cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size
+                    ? {
+                          ...cached,
+                          records: Array.isArray(cached.records)
+                              ? cached.records.filter((record) => record != null && record.at >= since)
+                              : []
+                      }
+                    : { mtimeMs: stat.mtimeMs, size: stat.size, records: await fileRecords(file, since) }
+            files[file] = entry
+            for (const record of entry.records) if (record.at >= since) records.push(record)
+        }
+    }
+    cache.files = files
+    return records
+}
+
+const EXCLUDED_TOKEN_PROVIDERS = new Set(['gmi', 'mistral', 'google', 'claude-bridge', 'commandcode'])
+
+export function providerTokenRows(
+    records: UsageRecord[],
+    now = Date.now(),
+    shown?: readonly string[]
+): ProviderTokenRow[] {
+    const present = [...new Set(records.map((record) => record.provider))]
+    const providers = shown
+        ? present.filter((provider) => shown.includes(provider))
+        : present.filter((provider) => !EXCLUDED_TOKEN_PROVIDERS.has(provider))
+    const groups = providers.map((provider) =>
+        TOKEN_WINDOWS.map(([window, start]) => {
+            const since = start(now)
+            const row: ProviderTokenRow = {
+                provider,
+                window,
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                costUsd: 0
+            }
+            for (const record of records) {
+                if (record.provider !== provider || record.at < since) continue
+                row.input += record.input
+                row.output += record.output
+                row.cacheRead += record.cacheRead
+                row.cacheWrite += record.cacheWrite
+                row.costUsd += record.costUsd
+            }
+            return row
+        }).filter((row) => totalTokens(row) > 0)
+    )
+    return groups.toSorted((a, b) => (a[0]?.provider ?? '').localeCompare(b[0]?.provider ?? '')).flat()
+}

package/src/cost/overhead.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { Validator, type Infer } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+/**
+ * What an extension spent on its own model calls, in one append-only file next to the other
+ * agent state. A child session and a harness-loop writer bill to the plan the person already
+ * has, and neither lands in the parent's transcript, so `/cost` cannot see them without this.
+ */
+const OverheadSchema = t.object({
+    at: t.number(),
+    extension: t.string(),
+    sessionId: t.string(),
+    purpose: t.string(),
+    input: t.number(),
+    output: t.number(),
+    costUsd: t.number()
+})
+const isOverheadSchema = new Validator(OverheadSchema).isValidObject
+
+export type OverheadRecord = Infer<typeof OverheadSchema>
+
+export interface ExtensionSpend {
+    calls: number
+    input: number
+    output: number
+    costUsd: number
+}
+
+export interface OverheadTotals extends ExtensionSpend {
+    byExtension: Map<string, ExtensionSpend>
+}
+
+export function overheadPath(agentDir: string): string {
+    return join(agentDir, 'overhead.jsonl')
+}
+
+export function readOverhead(agentDir: string, sessionId: string): OverheadRecord[] {
+    const path = overheadPath(agentDir)
+    if (!existsSync(path)) return []
+    const out: OverheadRecord[] = []
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        if (line.trim() === '') continue
+        try {
+            const parsed: unknown = JSON.parse(line)
+            if (isOverheadSchema(parsed) && parsed.sessionId === sessionId) out.push(parsed)
+        } catch {}
+    }
+    return out
+}
+
+export function sumOverhead(records: OverheadRecord[]): OverheadTotals {
+    const empty = (): ExtensionSpend => ({ calls: 0, input: 0, output: 0, costUsd: 0 })
+    const totals: OverheadTotals = { ...empty(), byExtension: new Map() }
+    for (const record of records) {
+        const row = totals.byExtension.get(record.extension) ?? empty()
+        row.calls += 1
+        row.input += record.input
+        row.output += record.output
+        row.costUsd += record.costUsd
+        totals.byExtension.set(record.extension, row)
+        totals.calls += 1
+        totals.input += record.input
+        totals.output += record.output
+        totals.costUsd += record.costUsd
+    }
+    return totals
+}