bg-task-band

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { BgTask } from '../types'
5
6// Answers "how are we looking?" without a turn: a band of the background
7// shells, monitors and agents Claude started, how long each has run against
8// its cap, and the last line each wrote. A toast when one ends.
9
10const tasks = atom({ plugin: 'bg-task-band', key: 'tasks' } as const, [])
11const now = atom({ plugin: 'bg-task-band', key: 'now' } as const, 0)
12
13const TICK_MS = 10_000
14const KEEP_DONE_MS = 90_000
15
16function minutes(ms: number): string {
17  const m = Math.floor(ms / 60_000)
18  return m < 1 ? `${Math.floor(ms / 1000)}s` : m < 60 ? `${m}m` : `${Math.floor(m / 60)}h${m % 60}m`
19}
20
21function clean(line: string): string {
22  // eslint-disable-next-line no-control-regex
23  return line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').replace(/\s+/g, ' ').trim().slice(0, 120)
24}
25
26async function findOutput($: EngineInterface, id: string): Promise<string> {
27  const uid = (await $.process.run(['id', '-u'])).stdout.trim()
28  const r = await $.process.run(['find', `/tmp/claude-${uid}`, '-maxdepth', '5', '-name', `${id}.output`])
29    .catch(() => undefined)
30  return r?.stdout.split('\n')[0]?.trim() ?? ''
31}
32
33async function lastLine($: EngineInterface, t: BgTask): Promise<string> {
34  if (!t.outputFile) return t.last
35  const r = await $.process.run(['tail', '-n', '5', t.outputFile]).catch(() => undefined)
36  if (!r || r.exitCode !== 0) return t.last
37  const lines = r.stdout.split('\n').map(clean).filter(l => l !== '')
38  return lines.at(-1) ?? t.last
39}
40
41async function track($: EngineInterface, t: Omit<BgTask, 'startedAt' | 'last' | 'status' | 'endedAt'>) {
42  const startedAt = await $.clock.now()
43  const outputFile = t.outputFile || (await findOutput($, t.id))
44  await update($, tasks, list => [
45    ...list.filter(x => x.id !== t.id),
46    { ...t, outputFile, startedAt, last: '', status: 'running' as const, endedAt: 0 },
47  ])
48}
49
50async function tick($: EngineInterface) {
51  const at = await $.clock.now()
52  const list = await read($, tasks)
53  const kept = list.filter(t => t.status === 'running' || at - t.endedAt < KEEP_DONE_MS)
54  const refreshed = await Promise.all(
55    kept.map(async t => (t.status === 'running' ? { ...t, last: await lastLine($, t) } : t)),
56  )
57  await update($, tasks, () => refreshed)
58  await update($, now, () => at)
59}
60
61export const register: Register = on => {
62  on('session.start', async ($, e, next) => {
63    $.clock.every(TICK_MS, () => void tick($))
64    return next(e)
65  })
66
67  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
68    const ran = await next(e)
69    if (ran.deny !== undefined || ran.isError) return ran
70    const id = ran.result.backgroundTaskId
71    if (id) {
72      await track($, {
73        id,
74        kind: 'shell',
75        label: e.description || e.command.slice(0, 80),
76        capMs: e.timeout ?? 0,
77        outputFile: '',
78      })
79    }
80    return ran
81  })
82
83  on('tool.call', { tool: 'Monitor' }, async ($, e, next) => {
84    const ran = await next(e)
85    if (ran.deny !== undefined || ran.isError) return ran
86    await track($, {
87      id: ran.result.taskId,
88      kind: 'monitor',
89      label: e.description,
90      capMs: ran.result.persistent ? 0 : ran.result.timeoutMs,
91      outputFile: '',
92    })
93    return ran
94  })
95
96  on('tool.call', { tool: 'Agent' }, async ($, e, next) => {
97    const ran = await next(e)
98    if (ran.deny !== undefined || ran.isError) return ran
99    const r = ran.result
100    if ('status' in r && r.status === 'async_launched') {
101      await track($, { id: r.agentId, kind: 'agent', label: r.description, capMs: 0, outputFile: r.outputFile })
102    }
103    return ran
104  })
105
106  // Background tasks report back as task-notification prompts.
107  on('prompt.submit', async ($, e, next) => {
108    if (e.origin.kind !== 'task-notification') return next(e)
109    const id = e.text.match(/<task-id>([^<]+)<\/task-id>/)?.[1]
110    const status = e.text.match(/<status>([^<]+)<\/status>/)?.[1]
111    const event = e.text.match(/<event>([\s\S]*?)<\/event>/)?.[1]
112    const list = await read($, tasks)
113    const t = list.find(x => x.id === id)
114    if (!t) return next(e)
115
116    const at = await $.clock.now()
117    if (status === 'completed' || status === 'failed' || status === 'killed') {
118      await update($, tasks, l => l.map(x => (x.id === t.id ? { ...x, status, endedAt: at } : x)))
119      const mark = status === 'completed' ? '✓' : '✗'
120      $.ui.toast(`${mark} ${t.label} (${status}, ${minutes(at - t.startedAt)})`, { timeoutMs: 8000 })
121    } else if (event) {
122      const line = clean(event.split('\n').filter(l => l.trim() !== '').at(-1) ?? '')
123      await update($, tasks, l => l.map(x => (x.id === t.id ? { ...x, last: line } : x)))
124    }
125    return next(e)
126  })
127
128  // A TaskStop ends the task without a notification.
129  on('tool.call', { tool: 'TaskStop' }, async ($, e, next) => {
130    const ran = await next(e)
131    const id = e.task_id ?? e.shell_id ?? ''
132    const at = await $.clock.now()
133    await update($, tasks, l => l.map(x => (x.id === id ? { ...x, status: 'killed' as const, endedAt: at } : x)))
134    return ran
135  })
136
137  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
138    const list = await read($, tasks)
139    const at = await read($, now)
140    if (list.length === 0 || e.props.hasSurvey) return next(e)
141    const { Box, Text } = $.ui.resolve(e)
142    const running = list.filter(t => t.status === 'running')
143    const icon = { running: '⏳', completed: '✓', failed: '✗', killed: '■' } as const
144    const color = { running: 'yellow', completed: 'green', failed: 'red', killed: 'gray' } as const
145
146    return (
147      <Box flexDirection="column">
148        {list.slice(-4).map(t => {
149          const elapsed = minutes(Math.max(0, (t.status === 'running' ? at : t.endedAt) - t.startedAt))
150          return (
151            <Box key={t.id}>
152              <Text color={color[t.status]}>{icon[t.status]} </Text>
153              <Text>{t.label.slice(0, 50)} </Text>
154              <Text dimColor>
155                {elapsed}
156                {t.capMs > 0 ? `/${minutes(t.capMs)}` : ''}{' '}
157              </Text>
158              {t.last !== '' && (
159                <Text dimColor wrap="truncate">
160                  · {t.last}
161                </Text>
162              )}
163            </Box>
164          )
165        })}
166        {running.length > 4 && <Text dimColor>{running.length} running in all</Text>}
167      </Box>
168    )
169  })
170}
171

1export type BgTask = {
2  id: string
3  kind: 'shell' | 'monitor' | 'agent'
4  label: string
5  startedAt: number
6  capMs: number
7  outputFile: string
8  last: string
9  status: 'running' | 'completed' | 'failed' | 'killed'
10  endedAt: number
11}
12
13declare module 'claude-code' {
14  interface PluginState {
15    'bg-task-band': {
16      tasks: BgTask[]
17      now: number
18    }
19  }
20}
21