cc-mod-caffeinate

1import type { EngineInterface, Register } from 'claude-code'
2
3// Each session holds its own `caffeinate` while it works. macOS keeps the
4// display awake while any process holds an assertion, so several sessions
5// combine on their own: the screen may sleep only once none is working.
6
7// A bounded lease, renewed while active, so a session that dies without
8// unloading never leaves an orphan caffeinate holding the screen for long.
9const LEASE_SECONDS = 300
10
11const WAITING_NOTIFICATION = /permission|elicitation|idle/
12
13// -d keeps the display on; -i stops idle sleep; -s, opted into, also stops
14// lid-closed sleep, which macOS honours on AC power only.
15let flags: string[] = []
16let showStatus = true
17
18let isTurnRunning = false
19let isWaiting = false
20let lease: AsyncGenerator<unknown, unknown> | undefined
21
22function shouldHold() {
23  return isTurnRunning && !isWaiting
24}
25
26async function hold($: EngineInterface) {
27  while (shouldHold()) {
28    let child: ReturnType<EngineInterface['process']['spawn']> | undefined
29    let code: number | null = null
30    try {
31      child = $.process.spawn({
32        argv: ['/usr/bin/caffeinate', ...flags, '-t', String(LEASE_SECONDS)],
33      })
34      lease = child
35      for await (const _ of child) {
36        // caffeinate writes nothing; the loop lasts the child's life
37      }
38      code = (await child.result).code
39    } catch {
40      // could not start, or killed by a release
41    }
42    if (lease !== child) return // released, or a newer hold took over
43    // Only a lease that ran out is renewed; any other end would respawn in a spin.
44    if (code !== 0) {
45      lease = undefined
46      return
47    }
48  }
49}
50
51function sync($: EngineInterface) {
52  const isHolding = shouldHold()
53  if (showStatus) $.ui.status(isHolding ? '☕' : undefined)
54  if (isHolding && !lease) void hold($)
55  if (!isHolding && lease) {
56    // Not awaited: a pending pull on a silent child may hold return() back.
57    void lease.return(undefined).catch(() => {})
58    lease = undefined
59  }
60}
61
62function setRunning($: EngineInterface, value: boolean) {
63  isTurnRunning = value
64  isWaiting = false
65  sync($)
66}
67
68function setWaiting($: EngineInterface, value: boolean) {
69  if (isWaiting === value) return
70  isWaiting = value
71  sync($)
72}
73
74export const register: Register = (on, options) => {
75  flags = ['-d', '-i', ...(options.keepAwakeLidClosed === true ? ['-s'] : [])]
76  showStatus = options.showStatus !== false
77
78  on('turn.start', ($, e, next) => {
79    setRunning($, true)
80    return next(e)
81  })
82
83  on('turn.complete', ($, e, next) => {
84    // A subagent's turn ending is not the session going idle.
85    if (e.agentId === undefined) setRunning($, false)
86    return next(e)
87  })
88
89  on('session.end', ($, e, next) => {
90    setRunning($, false)
91    return next(e)
92  })
93
94  on('classic.PermissionRequest', ($, e, next) => {
95    setWaiting($, true)
96    return next(e)
97  })
98
99  on('classic.Elicitation', ($, e, next) => {
100    setWaiting($, true)
101    return next(e)
102  })
103
104  on('classic.Notification', ($, e, next) => {
105    if (WAITING_NOTIFICATION.test(e.notification_type)) setWaiting($, true)
106    return next(e)
107  })
108
109  on('tool.call', { tool: 'AskUserQuestion' }, async ($, e, next) => {
110    setWaiting($, true)
111    try {
112      return await next(e)
113    } finally {
114      setWaiting($, false)
115    }
116  })
117
118  // No event says a permission prompt was answered; these are the first
119  // signs that the turn went on after one.
120  on('classic.PostToolUse', ($, e, next) => {
121    setWaiting($, false)
122    return next(e)
123  })
124
125  on('classic.PostToolUseFailure', ($, e, next) => {
126    setWaiting($, false)
127    return next(e)
128  })
129
130  on('classic.PermissionDenied', ($, e, next) => {
131    setWaiting($, false)
132    return next(e)
133  })
134
135  on('classic.ElicitationResult', ($, e, next) => {
136    setWaiting($, false)
137    return next(e)
138  })
139
140  on('turn.step', async function* ($, e, next) {
141    setWaiting($, false)
142    return yield* next(e)
143  })
144}
145