usage-band

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { ClaudeStatus, Limit } from '../types'
5import { crossedAlerts, toSent } from './alerts'
6import { STATUS_TEXT, meter, parseStatus, sortLimits, toLimits } from './format'
7
8const limits = atom({ plugin: 'usage-band', key: 'limits' } as const, [])
9const claude = atom({ plugin: 'usage-band', key: 'claude' } as const, { level: 'pending' })
10const now = atom({ plugin: 'usage-band', key: 'now' } as const, 0)
11
12const STATUS_URL = 'https://status.claude.com/api/v2/summary.json'
13const STATUS_EVERY_MS = 5 * 60_000
14const TICK_MS = 60_000
15const LIMITS_KEY = 'limits'
16const ALERTS_KEY = 'alerts'
17const ALERT_TOAST_MS = 10_000
18const CHIP_BAR_WIDTH = 6
19const CHIP_BAR_MIN_COLUMNS = 72
20
21const STATUS_COLOR: Record<ClaudeStatus['level'], string> = {
22  pending: 'subtle',
23  ok: 'success',
24  minor: 'warning',
25  major: 'error',
26  maintenance: 'suggestion',
27  unknown: 'subtle',
28}
29
30async function alertCrossed($: EngineInterface, live: Limit[]): Promise<void> {
31  const { alerts, sent } = crossedAlerts(live, toSent(await $.store.get(ALERTS_KEY)), await $.clock.now())
32  await $.store.set(ALERTS_KEY, sent)
33  for (const text of alerts) $.ui.toast(text, { timeoutMs: ALERT_TOAST_MS })
34}
35
36async function saveLimits($: EngineInterface, live: Limit[]): Promise<void> {
37  if (live.length === 0) return
38  await update($, limits, () => live)
39  await $.store.set(LIMITS_KEY, live)
40  await alertCrossed($, live)
41}
42
43async function loadLimits($: EngineInterface): Promise<void> {
44  const live = toLimits((await $.session.usage()).rateLimits)
45  if (live.length > 0) return saveLimits($, live)
46
47  const stored = toLimits(await $.store.get(LIMITS_KEY))
48  if (stored.length > 0) await update($, limits, () => stored)
49}
50
51async function refreshStatus($: EngineInterface): Promise<void> {
52  const status = await $.http.fetch(STATUS_URL).then(
53    res => (res.ok ? parseStatus(res.text) : { level: 'unknown' as const }),
54    () => ({ level: 'unknown' as const }),
55  )
56  await update($, claude, () => status)
57}
58
59async function tick($: EngineInterface): Promise<void> {
60  const at = await $.clock.now()
61  await update($, now, () => at)
62}
63
64export const register: Register = on => {
65  on('session.start', async ($, e, next) => {
66    await Promise.all([tick($), loadLimits($)])
67    void refreshStatus($)
68    $.clock.every(TICK_MS, () => void tick($))
69    $.clock.every(STATUS_EVERY_MS, () => void refreshStatus($))
70
71    return next(e)
72  })
73
74  on('session.measure', async ($, e, next) => {
75    if (e.changed.includes('rateLimits')) await saveLimits($, toLimits(e.rateLimits))
76
77    return next(e)
78  })
79
80  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
81    const below = await next(e)
82    if (e.props.hasSurvey) return below
83
84    const { Box, Text } = $.ui.resolve(e)
85    const [list, status, at] = await Promise.all([read($, limits), read($, claude), read($, now)])
86    const columns = e.props.bodyColumns
87    const hasBars = columns >= CHIP_BAR_MIN_COLUMNS
88    const meters = sortLimits(list).map(limit => meter(limit, at, CHIP_BAR_WIDTH))
89
90    const chip = (
91      <Box flexDirection="row" columnGap={2}>
92        {meters.length === 0 ? <Text dimColor>사용량 대기 중</Text> : ''}
93        {meters.map(m => (
94          <Text>
95            <Text bold>{m.label}</Text>{' '}
96            {hasBars ? <Text color={m.tone}>{m.filled}</Text> : ''}
97            {hasBars ? <Text dimColor>{`${m.rest} `}</Text> : ''}
98            <Text color={m.tone} bold>{`${m.percent}%`}</Text>
99            {m.reset ? <Text dimColor>{` ${m.reset}`}</Text> : ''}
100          </Text>
101        ))}
102        <Text>
103          <Text color={STATUS_COLOR[status.level]}>●</Text> {status.level === 'ok' ? '정상' : STATUS_TEXT[status.level]}
104        </Text>
105      </Box>
106    )
107
108    return (
109      <Box flexDirection="column">
110        <Box flexDirection="row" justifyContent="flex-end" width={columns}>
111          {chip}
112        </Box>
113        {below}
114      </Box>
115    )
116  })
117}
118

1import type { Limit } from '../types'
2import { hasReset, limitLabel, untilReset } from './format'
3
4export type Sent = Record<string, number>
5
6const THRESHOLDS = [80, 95]
7
8export function toSent(value: unknown): Sent {
9  if (typeof value !== 'object' || value === null) return {}
10  return Object.fromEntries(Object.entries(value).filter(([, v]) => typeof v === 'number'))
11}
12
13// 창마다 이미 알린 가장 높은 기준을 기억한다. 창이 초기화돼 사용률이 내려가면 기준도 내려가 다음에 다시 알린다.
14export function crossedAlerts(limits: readonly Limit[], sent: Sent, now: number): { alerts: string[]; sent: Sent } {
15  const next: Sent = { ...sent }
16  const alerts: string[] = []
17
18  for (const limit of limits) {
19    if (hasReset(limit, now)) continue
20
21    const crossed = Math.max(0, ...THRESHOLDS.filter(t => limit.percentUsed >= t))
22    if (crossed > (sent[limit.kind] ?? 0)) {
23      const reset = untilReset(limit.resetsAt, now)
24      alerts.push(`${limitLabel(limit.kind)} 사용량이 ${crossed}%를 넘었습니다${reset ? ` · ${reset} 뒤 초기화` : ''}`)
25    }
26    next[limit.kind] = crossed
27  }
28
29  return { alerts, sent: next }
30}
31

1import type { ClaudeStatus, ClaudeStatusLevel, Limit } from '../types'
2
3export type Tone = 'success' | 'warning' | 'error'
4
5export type Meter = { label: string; percent: number; tone: Tone; filled: string; rest: string; reset?: string }
6
7const LABEL: Record<string, string> = { five_hour: '5시간', seven_day: '주간', spend_limit: '지출 한도' }
8const ORDER = ['five_hour', 'seven_day']
9const WATCHED_COMPONENTS = ['Claude Code', 'Claude API (api.anthropic.com)', 'claude.ai']
10const OPEN_INCIDENT = ['investigating', 'identified', 'monitoring']
11
12export const STATUS_TEXT: Record<ClaudeStatusLevel, string> = {
13  pending: 'Claude status 확인 중',
14  ok: 'Claude 정상',
15  minor: 'Claude 일부 장애',
16  major: 'Claude 장애',
17  maintenance: 'Claude 점검 중',
18  unknown: 'Claude status 확인 불가',
19}
20
21export function limitLabel(kind: string): string {
22  return LABEL[kind] ?? kind
23}
24
25export function sortLimits(limits: readonly Limit[]): Limit[] {
26  const rank = (kind: string) => (ORDER.includes(kind) ? ORDER.indexOf(kind) : ORDER.length)
27  return [...limits].sort((a, b) => rank(a.kind) - rank(b.kind))
28}
29
30export function toLimits(value: unknown): Limit[] {
31  if (!Array.isArray(value)) return []
32  return value.flatMap(item => {
33    const { kind, percentUsed, resetsAt } = (item ?? {}) as Record<string, unknown>
34    if (typeof kind !== 'string' || typeof percentUsed !== 'number') return []
35    return [typeof resetsAt === 'string' ? { kind, percentUsed, resetsAt } : { kind, percentUsed }]
36  })
37}
38
39export function hasReset(limit: Limit, now: number): boolean {
40  const at = limit.resetsAt ? Date.parse(limit.resetsAt) : NaN
41  return !Number.isNaN(at) && at <= now
42}
43
44export function tone(percent: number): Tone {
45  if (percent >= 90) return 'error'
46  if (percent >= 70) return 'warning'
47  return 'success'
48}
49
50export function bar(percent: number, width: number): { filled: string; rest: string } {
51  const filled = Math.round((Math.min(Math.max(percent, 0), 100) / 100) * width)
52  return { filled: '━'.repeat(filled), rest: '─'.repeat(width - filled) }
53}
54
55export function meter(limit: Limit, now: number, width: number): Meter {
56  const percent = hasReset(limit, now) ? 0 : Math.round(limit.percentUsed)
57  const reset = untilReset(limit.resetsAt, now)
58  return {
59    label: limitLabel(limit.kind),
60    percent,
61    tone: tone(percent),
62    ...bar(percent, width),
63    ...(reset ? { reset } : {}),
64  }
65}
66
67export function untilReset(resetsAt: string | undefined, now: number): string | undefined {
68  const at = resetsAt ? Date.parse(resetsAt) : NaN
69  if (Number.isNaN(at)) return undefined
70
71  const minutes = Math.ceil((at - now) / 60_000)
72  if (minutes <= 0) return undefined
73
74  const days = Math.floor(minutes / 1440)
75  const hours = Math.floor((minutes % 1440) / 60)
76  const rest = minutes % 60
77  if (days > 0) return `${days}d${hours}h`
78  if (hours > 0) return `${hours}h${rest}m`
79  return `${rest}m`
80}
81
82type Summary = {
83  status?: { indicator?: string; description?: string }
84  incidents?: { name?: string; status?: string }[]
85  components?: { name?: string; status?: string }[]
86}
87
88export function parseStatus(text: string): ClaudeStatus {
89  let summary: Summary
90  try {
91    summary = JSON.parse(text) as Summary
92  } catch {
93    return { level: 'unknown' }
94  }
95
96  const incident = summary.incidents?.find(i => OPEN_INCIDENT.includes(i.status ?? ''))?.name
97  const degraded = (summary.components ?? [])
98    .filter(c => WATCHED_COMPONENTS.includes(c.name ?? '') && c.status !== 'operational')
99    .map(c => c.name)
100  const detail = incident ?? (degraded.length > 0 ? `${degraded.join(', ')} 영향` : undefined)
101
102  switch (summary.status?.indicator) {
103    case 'none':
104      return detail ? { level: 'minor', detail } : { level: 'ok' }
105    case 'minor':
106      return { level: 'minor', detail: detail ?? summary.status.description }
107    case 'major':
108    case 'critical':
109      return { level: 'major', detail: detail ?? summary.status.description }
110    case 'maintenance':
111      return { level: 'maintenance', detail }
112    default:
113      return { level: 'unknown' }
114  }
115}
116

1export type Limit = { kind: string; percentUsed: number; resetsAt?: string }
2
3export type ClaudeStatusLevel = 'pending' | 'ok' | 'minor' | 'major' | 'maintenance' | 'unknown'
4
5export type ClaudeStatus = { level: ClaudeStatusLevel; detail?: string }
6
7declare module 'claude-code' {
8  interface PluginState {
9    'usage-band': { limits: Limit[]; claude: ClaudeStatus; now: number }
10  }
11}
12