usage-percent

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register, SessionContextUsage, SessionRateLimit, Timer } from 'claude-code'
3
4import { containerOf, directoriesOf, isUnder, memory, pressureAvg10, servedIn, serveProcesses } from './machine'
5import type { ServeProcess } from './machine'
6import { dim, joined, toneOf } from './pieces'
7import { forgeOf, hostOf, githubPipeline, gitlabPipeline, pipeline } from './pipeline'
8import type { Pipeline } from './pipeline'
9import type { Piece } from '../types'
10
11const WINDOWS: Record<string, string> = { five_hour: '5h', seven_day: 'wk' }
12const TICK_MS = 10_000
13const PIPELINE_RUNNING_MS = 60_000
14const PIPELINE_IDLE_MS = 300_000
15const AFTER_PUSH_MS = 15_000
16
17const usageLine = atom({ plugin: 'usage-percent', key: 'line' } as const, null)
18const nxLine = atom({ plugin: 'usage-percent', key: 'nx' } as const, null)
19
20type Poll = { root: string; uid: string; head: string; pipelineAt: number; pushedAt: number; pipe: Pipeline | null; composeDirs: Map<string, string>; isBusy: boolean }
21
22function figure(label: string, percent: number): Piece[] {
23  return [dim(`${label} `), { text: `${Math.round(percent)}%`, tone: toneOf(percent) }]
24}
25
26export function isGitPush(command: string): boolean {
27  return /\bgit(?:\s+-[Cc]\s+\S+)*\s+push\b/.test(command)
28}
29
30export function line(context: SessionContextUsage, rateLimits: readonly SessionRateLimit[]): Piece[] {
31  const limits = rateLimits.flatMap(limit => {
32    const label = WINDOWS[limit.kind]
33    return label === undefined ? [] : [figure(label, limit.percentUsed)]
34  })
35  return joined([figure('ctx', context.percent ?? 0), ...limits], ' | ')
36}
37
38async function memoryPieces($: EngineInterface, uid: string): Promise<Piece[]> {
39  const service = `/sys/fs/cgroup/user.slice/user-${uid}.slice/user@${uid}.service`
40  const files = ['claude.slice/memory.current', 'claude.slice/memory.max', 'app.slice/memory.pressure']
41  const contents = await Promise.all(files.map(file => $.fs.read(`${service}/${file}`))).catch(() => null)
42  if (contents === null) {
43    return []
44  }
45  const [current = '', max = '', pressure = ''] = contents
46  return memory(Number(current), Number(max), pressureAvg10(pressure))
47}
48
49async function fetchPipeline($: EngineInterface, root: string): Promise<Pipeline | null> {
50  const git = (...args: string[]) => $.process.run(['git', ...args], { cwd: root }).then(r => r.stdout.trim())
51  const [remote, branch] = await Promise.all([git('remote', 'get-url', 'origin'), git('branch', '--show-current')])
52  const forge = forgeOf(remote)
53  if (forge === null || branch === '') {
54    return null
55  }
56  const argv = forge === 'github'
57    ? ['gh', 'run', 'list', '--branch', branch, '--limit', '1', '--json', 'status,conclusion,workflowName']
58    : ['glab', 'ci', 'get', '--branch', branch, '--output', 'json']
59  const run = await $.process.run(argv, { cwd: root, timeoutMs: 20_000 })
60  if (run.exitCode !== 0) {
61    // A failure is either no pipeline for the branch (show nothing) or a host the CLI is not logged in to.
62    const host = hostOf(remote)
63    const auth = await $.process.run([forge === 'github' ? 'gh' : 'glab', 'auth', 'status', '--hostname', host], { timeoutMs: 10_000 })
64    return auth.exitCode === 0 ? null : { state: 'no-login', detail: host }
65  }
66  return forge === 'github' ? githubPipeline(run.stdout) : gitlabPipeline(run.stdout)
67}
68
69// A server counts when it runs in the session's tree; one in a container counts when its compose project lives there.
70async function servedHere($: EngineInterface, poll: Poll, processes: readonly ServeProcess[]): Promise<string[]> {
71  if (processes.length === 0) {
72    return []
73  }
74  const pwdx = await $.process.run(['pwdx', ...processes.map(p => p.pid)])
75  const dirOf = directoriesOf(pwdx.stdout)
76  for (const { pid } of processes) {
77    if (isUnder(dirOf.get(pid) ?? '', poll.root)) {
78      continue
79    }
80    const container = containerOf(await $.fs.read(`/proc/${pid}/cgroup`).catch(() => ''))
81    if (container !== null) {
82      dirOf.set(pid, await composeDir($, poll, container))
83    }
84  }
85  return servedIn(poll.root, processes, dirOf)
86}
87
88async function composeDir($: EngineInterface, poll: Poll, container: string): Promise<string> {
89  if (!poll.composeDirs.has(container)) {
90    const label = '{{index .Config.Labels "com.docker.compose.project.working_dir"}}'
91    const run = await $.process.run(['docker', 'inspect', '--format', label, container], { timeoutMs: 10_000 }).catch(() => null)
92    poll.composeDirs.set(container, run?.exitCode === 0 ? run.stdout.trim() : '')
93  }
94  return poll.composeDirs.get(container) ?? ''
95}
96
97// Memory and servers every tick; the pipeline only when HEAD moved, after a push, or when its interval is up.
98async function tick($: EngineInterface, poll: Poll) {
99  if (poll.isBusy) {
100    return
101  }
102  poll.isBusy = true
103  try {
104    const [middle, ps, head] = await Promise.all([
105      memoryPieces($, poll.uid),
106      $.process.run(['ps', '-eo', 'pid,args']),
107      $.process.run(['git', 'rev-parse', 'HEAD'], { cwd: poll.root }).then(r => r.stdout.trim()),
108    ])
109    const now = await $.clock.now()
110    const interval = poll.pipe?.state === 'running' ? PIPELINE_RUNNING_MS : PIPELINE_IDLE_MS
111    const isPushSettled = poll.pushedAt > 0 && now - poll.pushedAt >= AFTER_PUSH_MS
112    if (head !== poll.head || isPushSettled || now - poll.pipelineAt >= interval) {
113      poll.head = head
114      poll.pipelineAt = now
115      poll.pushedAt = 0
116      poll.pipe = await fetchPipeline($, poll.root).catch(() => null)
117    }
118    const served = await servedHere($, poll, serveProcesses(ps.stdout)).catch(() => [])
119    const right = joined([served.length > 0 ? [dim(`▶ ${served.join(' ')}`)] : [], poll.pipe ? pipeline(poll.pipe) : []], ' · ')
120    await update($, nxLine, () => (middle.length > 0 || right.length > 0 ? { middle, right } : null))
121  } finally {
122    poll.isBusy = false
123  }
124}
125
126function startTick($: EngineInterface, poll: Poll): void {
127  void tick($, poll).catch((error: unknown) => $.ui.log(`usage-percent: ${String(error)}`, { to: 'debug' }))
128}
129
130export const register: Register = on => {
131  let poll: Poll | null = null
132  let timer: Timer | null = null
133
134  on('session.start', async ($, e, next) => {
135    const result = await next(e)
136    const { context, rateLimits } = await $.session.usage()
137    await update($, usageLine, () => line(context, rateLimits))
138
139    timer?.cancel()
140    timer = null
141    poll = null
142    const root = await $.session.root()
143    if (await $.fs.exists(`${root}/nx.json`)) {
144      const uid = (await $.process.run(['id', '-u'])).stdout.trim()
145      const current: Poll = { root, uid, head: '', pipelineAt: 0, pushedAt: 0, pipe: null, composeDirs: new Map(), isBusy: false }
146      poll = current
147      startTick($, current)
148      timer = $.clock.every(TICK_MS, () => startTick($, current))
149    }
150    return result
151  })
152
153  on('session.measure', async ($, e, next) => {
154    await update($, usageLine, () => line(e.context, e.rateLimits))
155    return next(e)
156  })
157
158  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
159    const result = await next(e)
160    if (poll !== null && isGitPush(e.command)) {
161      poll.pushedAt = await $.clock.now()
162    }
163    return result
164  })
165
166  on('ui.render', { component: 'PromptHint' }, async ($, e, next) => {
167    const left = (await read($, usageLine)) ?? []
168    const nx = await read($, nxLine)
169    const hint = await next(e)
170    if (left.length === 0 && nx === null) {
171      return hint
172    }
173
174    const { Box, Text } = $.ui.resolve(e)
175    const draw = (pieces: readonly Piece[]) => (
176      <Text>
177        {pieces.map(piece => (piece.tone === 'dim' ? <Text dimColor>{piece.text}</Text> : <Text color={piece.tone}>{piece.text}</Text>))}
178      </Text>
179    )
180
181    // Equal-width outer zones keep the memory zone centred.
182    return (
183      <Box flexDirection="column">
184        {hint}
185        <Box>
186          <Box width={0} flexGrow={1}>{draw(left)}</Box>
187          {nx && nx.middle.length > 0 ? <Box>{draw(nx.middle)}</Box> : null}
188          <Box width={0} flexGrow={1} justifyContent="flex-end">{draw(nx?.right ?? [])}</Box>
189        </Box>
190      </Box>
191    )
192  })
193}
194

1import { dim, toneOf } from './pieces'
2import type { Piece } from '../types'
3
4const GIB = 1024 ** 3
5
6export type ServeProcess = { pid: string; project: string }
7
8export function memory(current: number, max: number, pressureAvg10: number): Piece[] {
9  const used = { text: `${(current / GIB).toFixed(1)}G`, tone: Number.isFinite(max) ? toneOf((current / max) * 100) : 'dim' } as const
10  if (pressureAvg10 <= 0) {
11    return [dim('mem '), used]
12  }
13  return [dim('mem '), used, dim(' psi '), { text: `${Math.round(pressureAvg10)}%`, tone: toneOf(pressureAvg10, 20, 50) }]
14}
15
16export function pressureAvg10(pressureFile: string): number {
17  return Number(/^some avg10=([\d.]+)/m.exec(pressureFile)?.[1] ?? 0)
18}
19
20// From `ps -eo pid,args`. A server of nx's default project, or of every project, shows as plain `serve`.
21export function serveProcesses(ps: string): ServeProcess[] {
22  return [...ps.matchAll(/^\s*(\d+)\s.*?\bnx (.*)$/gm)].flatMap(m => servedProjects(m[2] ?? '').map(project => ({ pid: m[1] ?? '', project })))
23}
24
25function servedProjects(args: string): string[] {
26  const run = /^run ([\w.-]+):serve(?=[:\s]|$)/.exec(args)
27  if (run) {
28    return [run[1] ?? '']
29  }
30  const serve = /^serve(?=\s|$)(.*)/.exec(args)
31  if (serve) {
32    return [optionOf(serve[1] ?? '', 'project', 'p') ?? /^\s+(\w[\w.-]*)/.exec(serve[1] ?? '')?.[1] ?? 'serve']
33  }
34  if (/^run-many\b/.test(args) && /(?:^|,)serve(?:,|$)/.test(optionOf(args, 'targets', 't') ?? optionOf(args, 'target') ?? '')) {
35    return (optionOf(args, 'projects', 'p') ?? 'serve').split(',')
36  }
37  return []
38}
39
40function optionOf(args: string, name: string, short?: string): string | null {
41  const flag = short === undefined ? `--${name}` : `(?:--${name}|-${short})`
42  return new RegExp(`(?:^|\\s)${flag}(?:=|\\s+)([^\\s-][^\\s]*)`).exec(args)?.[1] ?? null
43}
44
45// From `pwdx <pid>...`: `1234: /dir` per line.
46export function directoriesOf(pwdx: string): Map<string, string> {
47  return new Map([...pwdx.matchAll(/^(\d+): (.+)$/gm)].map(m => [m[1] ?? '', m[2] ?? '']))
48}
49
50// From `/proc/<pid>/cgroup`: the Docker container the process runs in, if any.
51export function containerOf(cgroup: string): string | null {
52  return /\/docker-([0-9a-f]+)\.scope/.exec(cgroup)?.[1] ?? null
53}
54
55export function isUnder(dir: string, root: string): boolean {
56  return dir === root || dir.startsWith(`${root}/`)
57}
58
59export function servedIn(root: string, processes: readonly ServeProcess[], dirOf: ReadonlyMap<string, string>): string[] {
60  const names = processes.filter(p => isUnder(dirOf.get(p.pid) ?? '', root)).map(p => p.project)
61  return [...new Set(names)].sort()
62}
63

1import type { Piece, Tone } from '../types'
2
3export function toneOf(percent: number, warn = 80, alarm = 95): Tone {
4  return percent >= alarm ? 'red' : percent >= warn ? 'yellow' : 'dim'
5}
6
7export function dim(text: string): Piece {
8  return { text, tone: 'dim' }
9}
10
11export function joined(groups: readonly Piece[][], gap: string): Piece[] {
12  return groups.filter(group => group.length > 0).flatMap((group, i) => (i === 0 ? group : [dim(gap), ...group]))
13}
14

1import { dim } from './pieces'
2import type { Piece } from '../types'
3
4export type Pipeline = { state: 'running' | 'passed' | 'manual' | 'failed' | 'no-login'; detail: string }
5export type Forge = 'github' | 'gitlab'
6
7export function hostOf(remoteUrl: string): string {
8  return /^(?:[a-z+]+:\/\/)?(?:[^@/]+@)?([^/:]+)/i.exec(remoteUrl.trim())?.[1] ?? ''
9}
10
11export function forgeOf(remoteUrl: string): Forge | null {
12  if (remoteUrl.trim() === '') {
13    return null
14  }
15  if (/(^|[@/.])(dev\.azure|visualstudio)\.com[:/]/.test(remoteUrl)) {
16    return null
17  }
18  return /(^|[@/])github\.com[:/]/.test(remoteUrl) ? 'github' : 'gitlab'
19}
20
21type GitlabJob = { name?: string; status?: string; stage?: string }
22
23export function gitlabPipeline(json: string): Pipeline | null {
24  const p = JSON.parse(json) as { status?: string; jobs?: GitlabJob[] }
25  const jobs = p.jobs ?? []
26  switch (p.status) {
27    case 'running':
28    case 'pending':
29    case 'created':
30    case 'preparing':
31    case 'waiting_for_resource':
32      return { state: 'running', detail: jobs.find(job => job.status === 'running')?.stage ?? '' }
33    case 'failed':
34      return { state: 'failed', detail: jobs.filter(job => job.status === 'failed').map(job => job.name ?? '').join(' ') }
35    case 'canceled':
36      return { state: 'failed', detail: '' }
37    case 'success':
38      return { state: 'passed', detail: '' }
39    case 'manual':
40      return { state: 'manual', detail: '' }
41    default:
42      return null
43  }
44}
45
46type GithubRun = { status?: string; conclusion?: string; workflowName?: string }
47
48export function githubPipeline(json: string): Pipeline | null {
49  const run = (JSON.parse(json) as GithubRun[])[0]
50  if (run === undefined) {
51    return null
52  }
53  if (run.status === 'waiting' || run.status === 'pending' || run.status === 'action_required' || run.conclusion === 'action_required') {
54    return { state: 'manual', detail: run.workflowName ?? '' }
55  }
56  if (run.status !== 'completed') {
57    return { state: 'running', detail: run.workflowName ?? '' }
58  }
59  if (run.conclusion === 'success' || run.conclusion === 'skipped' || run.conclusion === 'neutral') {
60    return { state: 'passed', detail: '' }
61  }
62  return { state: 'failed', detail: run.workflowName ?? '' }
63}
64
65export function pipeline(p: Pipeline): Piece[] {
66  if (p.state === 'no-login') {
67    return [dim(`ci no login (${p.detail})`)]
68  }
69  const glyph = { running: '⏳', passed: '✓', manual: '⏸', failed: '✗' }[p.state]
70  const tone = p.state === 'failed' ? 'red' : p.state === 'passed' ? 'green' : 'dim'
71  const detail = p.detail.toLowerCase() === 'ci' ? '' : p.detail
72  return [dim('ci '), { text: detail === '' ? glyph : `${glyph} ${detail}`, tone }]
73}
74

1export type Tone = 'dim' | 'yellow' | 'red' | 'green'
2export type Piece = { text: string; tone: Tone }
3export type UsageLine = Piece[] | null
4export type NxLine = { middle: Piece[]; right: Piece[] } | null
5
6declare module 'claude-code' {
7  interface PluginState {
8    'usage-percent': { line: UsageLine; nx: NxLine }
9  }
10}
11