night-mode

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, PromptComposeSection, Register } from 'claude-code'
3
4import { clockText, isBetween, localTime, minutesOf, spoken, type LocalTime } from './clock'
5import { classify, shorten } from './risky'
6
7const isOff = atom({ plugin: 'night-mode', key: 'isOff' } as const, false)
8const shipUntil = atom({ plugin: 'night-mode', key: 'shipUntil' } as const, 0)
9
10const SHIP_MINUTES = 10
11const YES_SHIP_IT = /^\W*yes,?\s+ship\s+it\b/i
12const RUN_IT = 'Run it'
13
14type Night = { start: number; end: number; timeZone: string }
15
16const sectionOf = (night: Night): PromptComposeSection => ({
17  id: 'night-mode:late',
18  scope: 'session',
19  text: [
20    '# Night mode',
21    `It is late at night for the person you are working with (between ${clockText(night.start)} and ${clockText(night.end)} their time), when tired mistakes are easy to make. Be more careful than usual:`,
22    '- Double-check anything destructive or hard to undo (deletes, force pushes, migrations, deploys, publishes) before you run it, and say what it will do.',
23    '- Prefer reversible steps: a branch over main, a preview deploy over production, a backup or dry run before the real thing.',
24    '- Before risky work, summarise the risks in a sentence or two and let the person decide.',
25    '- Keep replies short and clear. If something can safely wait until morning, say so.',
26  ].join('\n'),
27})
28
29/** The local time when night mode is on and it is night, else undefined. */
30const nightTime = async ($: EngineInterface, night: Night): Promise<LocalTime | undefined> => {
31  if (await read($, isOff)) return undefined
32  const zone = night.timeZone || (await $.env.get('TZ'))
33  const time = localTime(await $.clock.now(), zone)
34
35  return isBetween(time, night.start, night.end) ? time : undefined
36}
37
38const showStatus = async ($: EngineInterface, night: Night) => {
39  const time = await nightTime($, night)
40  const isCleared = (await read($, shipUntil)) > (await $.clock.now())
41  const status = `🌙 night mode until ${clockText(night.end)}${isCleared ? ' · cleared to ship' : ''}`
42
43  $.ui.status(time ? status : undefined)
44}
45
46const nightCommand = async ($: EngineInterface, night: Night, args: string): Promise<string> => {
47  const hours = `${clockText(night.start)}–${clockText(night.end)}`
48  if (args === 'off') {
49    await update($, isOff, () => true)
50    return 'Night mode is off for the rest of this session. `/night on` brings it back.'
51  }
52  if (args === 'on') await update($, isOff, () => false)
53  if (await read($, isOff)) return `Night mode is off for this session (\`/night on\` to resume; hours ${hours}).`
54  const time = await nightTime($, night)
55
56  return time
57    ? `Night mode is on: it's ${spoken(time)}, careful until ${clockText(night.end)}. \`/night off\` to stop.`
58    : `Night mode is on and wakes up between ${hours} local time.`
59}
60
61export const register: Register = (on, options) => {
62  const night: Night = {
63    start: minutesOf(String(options.start)) ?? 60,
64    end: minutesOf(String(options.end)) ?? 300,
65    timeZone: String(options.timezone ?? '').trim(),
66  }
67
68  on('session.start', async ($, e, next) => {
69    await $.command.register({
70      name: 'night',
71      description: 'Night mode: show it, or turn it off or on for this session',
72      argumentHint: 'off | on',
73    })
74    await showStatus($, night)
75    $.clock.every(30_000, () => void showStatus($, night).catch(() => undefined))
76
77    return next(e)
78  })
79
80  on('command.run', { command: 'night' }, async ($, e) => {
81    const text = await nightCommand($, night, e.args.trim().toLowerCase())
82    await showStatus($, night)
83
84    return { text }
85  })
86
87  on('prompt.compose', async ($, e, next) => {
88    const composed = await next(e)
89    if (!(await nightTime($, night))) return composed
90
91    return { sections: [...composed.sections, sectionOf(night)] }
92  })
93
94  // "yes, ship it" from the person clears risky commands for a few minutes.
95  on('prompt.submit', async ($, e, next) => {
96    const isPerson = e.origin.kind === 'composer' || e.origin.kind === 'bridge'
97    if (!isPerson || !YES_SHIP_IT.test(e.text) || !(await nightTime($, night))) return next(e)
98
99    const until = (await $.clock.now()) + SHIP_MINUTES * 60_000
100    await update($, shipUntil, () => until)
101    $.ui.toast(`🌙 ok: risky commands run without asking for ${SHIP_MINUTES} minutes`)
102    await showStatus($, night)
103    const note = `night-mode: the person confirmed ("yes, ship it"). Risky commands run without asking for the next ${SHIP_MINUTES} minutes; you may retry the one that was held.`
104
105    return next({ ...e, context: [...(e.context ?? []), note] })
106  })
107
108  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
109    const label = classify(e.command)
110    if (label === undefined) return next(e)
111    const time = await nightTime($, night)
112    if (!time || (await read($, shipUntil)) > (await $.clock.now())) return next(e)
113
114    const when = spoken(time)
115    const command = shorten(e.command, 60)
116    const answer = await $.ui
117      .ask(`It's ${when}. Run this ${label} (${command})?`, {
118        header: 'Night mode',
119        options: [RUN_IT, 'Not tonight'],
120      })
121      .catch(() => undefined) // dismissed, or nobody to ask (claude -p)
122    if (answer === RUN_IT || (answer !== undefined && YES_SHIP_IT.test(answer))) return next(e)
123
124    return {
125      deny: [
126        `night mode held this ${label} (\`${shorten(e.command)}\`): it's ${when}. if you're sure, run it yourself or reply 'yes, ship it'.`,
127        "Tell the person exactly that. Don't retry it or work around it with another command; carry on with anything that doesn't need it.",
128      ].join('\n'),
129    }
130  })
131}
132

1// Local wall-clock time, and whether it falls inside the night window.
2
3export type LocalTime = { hour: number; minute: number }
4
5/** The time of day at `ms`, in `timeZone` (an IANA name) or else this machine's. */
6export const localTime = (ms: number, timeZone?: string): LocalTime => {
7  if (timeZone) {
8    try {
9      const parts = new Intl.DateTimeFormat('en-GB', {
10        timeZone,
11        hour: '2-digit',
12        minute: '2-digit',
13        hourCycle: 'h23',
14      }).formatToParts(ms)
15      const part = (type: string) => Number(parts.find(one => one.type === type)?.value)
16      const time = { hour: part('hour') % 24, minute: part('minute') }
17      if (Number.isInteger(time.hour) && Number.isInteger(time.minute)) return time
18    } catch {
19      // not a time zone this runtime knows: use the machine's
20    }
21  }
22  const date = new Date(ms)
23
24  return { hour: date.getHours(), minute: date.getMinutes() }
25}
26
27/** Minutes after midnight for "1", "01:00" or "1:30"; undefined for anything else. */
28export const minutesOf = (text: string): number | undefined => {
29  const match = /^\s*(\d{1,2})(?::(\d{2}))?\s*$/.exec(text)
30  const hour = Number(match?.[1])
31  const minute = Number(match?.[2] ?? 0)
32
33  return match && hour < 24 && minute < 60 ? hour * 60 + minute : undefined
34}
35
36/** Whether `time` is in [start, end), a window that may wrap past midnight. */
37export const isBetween = (time: LocalTime, start: number, end: number): boolean => {
38  const now = time.hour * 60 + time.minute
39
40  return start <= end ? now >= start && now < end : now >= start || now < end
41}
42
43/** "05:00" */
44export const clockText = (minutes: number): string =>
45  `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}`
46
47/** "2:41am" */
48export const spoken = ({ hour, minute }: LocalTime): string =>
49  `${hour % 12 || 12}:${String(minute).padStart(2, '0')}${hour < 12 ? 'am' : 'pm'}`
50

1// Which shell commands count as risky: deploys, force pushes, rm -rf,
2// publishes, infra changes, destructive SQL. The same table as the whoopgate
3// mod, ported from whoopgate's Swift classifier.
4
5export const RISKY: readonly (readonly [label: string, pattern: RegExp])[] = [
6  ['force push', /\bgit\s+push\b[^|;&]*\s(--force|--force-with-lease|-f)\b/],
7  ['push to main', /\bgit\s+push\b[^|;&]*\s(\S+\s+)?(main|master)\b/],
8  ['hard reset', /\bgit\s+reset\b[^|;&]*--hard\b/],
9  ['git clean', /\bgit\s+clean\s+-[a-zA-Z]*f/],
10  ['branch delete', /\bgit\s+branch\s+(-D|--delete\s+--force)\b/],
11  [
12    'rm -rf',
13    /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r|-r\s+-f|-f\s+-r|--recursive\s+--force|--force\s+--recursive)\b/,
14  ],
15  [
16    'prod deploy',
17    /\b(wrangler\s+(deploy|publish)|vercel\b[^|;&]*--prod|netlify\s+deploy\b[^|;&]*--prod|fly(ctl)?\s+deploy|railway\s+up|firebase\s+deploy|serverless\s+deploy|sls\s+deploy|cdk\s+deploy|eas\s+submit)\b/,
18  ],
19  ['publish', /\b(npm|pnpm|yarn|bun)\s+publish\b|\bcargo\s+publish\b|\btwine\s+upload\b/],
20  [
21    'infra change',
22    /\bterraform\s+(apply|destroy)\b|\bkubectl\s+(delete|apply|drain)\b|\bhelm\s+(upgrade|uninstall)\b/,
23  ],
24  ['destructive SQL', /\b(drop\s+(table|database|schema)|truncate\s+table)\b/i],
25  ['destructive SQL', /\b(psql|mysql|mariadb|sqlite3)\b.*\btruncate\s+\w/is],
26  ['PR merge', /\bgh\s+pr\s+merge\b/],
27  ['release', /\bgh\s+release\s+create\b/],
28]
29
30/** A bare `git push`, risky only while the checkout sits on main or master. */
31export const BARE_PUSH = /\bgit\s+push\b/
32
33/**
34 * The label of the first rule `command` breaks, or undefined when it is safe.
35 * `extra` are the person's own patterns; `branch` the current git branch.
36 */
37export const classify = (
38  command: string,
39  extra: readonly RegExp[] = [],
40  branch?: string,
41): string | undefined => {
42  for (const [label, pattern] of RISKY) if (pattern.test(command)) return label
43  for (const pattern of extra) if (pattern.test(command)) return 'custom rule'
44  const isOnMain = branch === 'main' || branch === 'master'
45
46  return isOnMain && BARE_PUSH.test(command) ? 'push to main' : undefined
47}
48
49/** One line of a command, cut to fit a message. */
50export const shorten = (command: string, max = 80): string => {
51  const line = command.trim().replace(/\s+/g, ' ')
52
53  return line.length > max ? `${line.slice(0, max - 3)}...` : line
54}
55

1/** Milliseconds since the epoch. */
2export type EpochMs = number
3
4// Night mode's session values: whether `/night off` switched it off, and
5// until when "yes, ship it" lets risky commands run without asking.
6declare module 'claude-code' {
7  interface PluginState {
8    'night-mode': { isOff: boolean; shipUntil: EpochMs }
9  }
10}
11