waiting

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register, Timer } from 'claude-code'
3
4import type { Beacon, SessionState, Waiter } from '../types'
5
6const others = atom({ plugin: 'waiting', key: 'others' } as const, [] as Waiter[])
7
8const HEARTBEAT_MS = 10_000
9const POLL_MS = 3_000
10// A beacon not rewritten for this long belongs to a session that is gone.
11const STALE_MS = 35_000
12// Beacons this old are deleted rather than skipped.
13const PRUNE_MS = 24 * 60 * 60 * 1000
14// Waits answered within this time never notify.
15const NOTIFY_AFTER_MS = 15_000
16
17const folderOf = (cwd: string) => cwd.split('/').filter(Boolean).slice(-2).join('/') || cwd
18
19// One session per module instance: these are this session's own beacon and
20// settings, set again on every (re)load by `register` and `session.start`.
21let shouldNotify = true
22let showYourTurn = false
23let dir = ''
24let me: Beacon | undefined
25let notifyTimer: Timer | undefined
26
27async function write($: EngineInterface) {
28  if (!me || !dir) return
29  me = { ...me, seen: await $.clock.now() }
30  await $.fs.write(`${dir}/${me.sessionId}.json`, JSON.stringify(me))
31}
32
33async function setState($: EngineInterface, state: SessionState, reason: string) {
34  if (!me) return
35  if (me.state === state && me.reason === reason) return
36  me = { ...me, state, reason, since: await $.clock.now() }
37  await write($)
38
39  notifyTimer?.cancel()
40  notifyTimer = undefined
41  if (state === 'waiting' && shouldNotify) {
42    const waitedFor = me.since
43    notifyTimer = $.clock.after(NOTIFY_AFTER_MS, () => {
44      if (me?.state !== 'waiting' || me.since !== waitedFor) return
45      void $.ui.notify(`${folderOf(me.cwd)}: ${me.reason}`, { title: 'Claude is waiting for you' })
46    })
47  }
48}
49
50async function poll($: EngineInterface) {
51  if (!dir) return
52  const now = await $.clock.now()
53  let entries: Awaited<ReturnType<EngineInterface['fs']['list']>> = []
54  try {
55    entries = await $.fs.list(dir)
56  } catch {
57    return
58  }
59  const found: Waiter[] = []
60  for (const entry of entries) {
61    if (entry.kind !== 'file' || !entry.name.endsWith('.json')) continue
62    if (me && entry.name === `${me.sessionId}.json`) continue
63    const path = `${dir}/${entry.name}`
64    let beacon: Beacon
65    try {
66      beacon = JSON.parse(String(await $.fs.read(path))) as Beacon
67    } catch {
68      continue
69    }
70    if (now - beacon.seen > PRUNE_MS || beacon.state === 'closed') {
71      void $.process.run(['rm', '-f', path]).catch(() => undefined)
72      continue
73    }
74    if (now - beacon.seen > STALE_MS) continue
75    const isWaiting = beacon.state === 'waiting' || (showYourTurn && beacon.state === 'idle' && beacon.reason !== '')
76    if (!isWaiting) continue
77    found.push({
78      sessionId: beacon.sessionId,
79      folder: folderOf(beacon.cwd),
80      reason: beacon.reason,
81      minutes: Math.floor((now - beacon.since) / 60_000),
82    })
83  }
84  found.sort((a, b) => b.minutes - a.minutes || a.folder.localeCompare(b.folder))
85  // Rewriting an equal list would redraw the band every poll for nothing.
86  const before = await read($, others)
87  if (JSON.stringify(before) !== JSON.stringify(found)) await update($, others, () => found)
88}
89
90export const register: Register = (on, options) => {
91  shouldNotify = options.notify !== false
92  showYourTurn = options.showYourTurn === true
93
94  on('session.start', async ($, e, next) => {
95    const home = (await $.env.get('HOME')) ?? ''
96    dir = `${home}/.claude/cache/waiting`
97    const now = await $.clock.now()
98    me = { sessionId: await $.session.id(), cwd: await $.session.cwd(), state: 'idle', reason: '', since: now, seen: now }
99    await write($)
100    $.clock.every(HEARTBEAT_MS, () => void write($))
101    $.clock.every(POLL_MS, () => void poll($))
102    void poll($)
103
104    return next(e)
105  })
106
107  on('session.end', async ($, e, next) => {
108    await setState($, 'closed', '')
109
110    return next(e)
111  })
112
113  on('prompt.submit', async ($, e, next) => {
114    await setState($, 'working', '')
115
116    return next(e)
117  })
118
119  on('classic.PermissionRequest', async ($, e, next) => {
120    await setState($, 'waiting', `permission for ${e.tool_name}`)
121
122    return next(e)
123  })
124
125  on('classic.Notification', async ($, e, next) => {
126    if (/permission/.test(e.notification_type) && me?.state !== 'waiting') {
127      await setState($, 'waiting', 'needs your permission')
128    } else if (/elicitation/.test(e.notification_type)) {
129      await setState($, 'waiting', 'has a question')
130    }
131
132    return next(e)
133  })
134
135  on('tool.call', async ($, e, next) => {
136    if (e.tool === 'AskUserQuestion') await setState($, 'waiting', 'has a question')
137    const result = await next(e)
138    // The call is through, so whatever it waited on (a question, a
139    // permission) has been answered.
140    if (me?.state === 'waiting') await setState($, 'working', '')
141
142    return result
143  })
144
145  on('turn.complete', async ($, e, next) => {
146    await setState($, 'idle', 'finished, your turn')
147
148    return next(e)
149  })
150
151  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
152    const list = await read($, others)
153    if (list.length === 0 || e.props.hasSurvey) return next(e)
154
155    const { Text } = $.ui.resolve(e)
156    const parts = list.map(w => `${w.folder}: ${w.reason}${w.minutes > 0 ? ` (${w.minutes}m)` : ''}`)
157
158    return (
159      <Text wrap="truncate">
160        <Text color="yellow">⏳ {list.length} waiting</Text>
161        <Text dimColor> · </Text>
162        {parts.join(' · ')}
163      </Text>
164    )
165  })
166}
167

1export type SessionState = 'working' | 'waiting' | 'idle' | 'closed'
2
3// One session's line in the shared folder, rewritten on every change and on
4// a heartbeat, so a reader can tell a live session from one that crashed.
5export type Beacon = {
6  sessionId: string
7  cwd: string
8  state: SessionState
9  reason: string
10  since: number
11  seen: number
12}
13
14export type Waiter = { sessionId: string; folder: string; reason: string; minutes: number }
15
16declare module 'claude-code' {
17  interface PluginState {
18    waiting: { others: Waiter[] }
19  }
20}
21