configuration

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { ModSetting } from '../types'
5
6// The kit's Configuration pane: every mod's settings. The pane mods depend on this one, so it comes
7// with any of them; dnd's Do not disturb pane opens from here as a tab of its own.
8const PANE = 'configuration'
9const TITLE = 'Configuration'
10const COMMAND = 'configuration'
11const DND_PANE = 'dnd'
12const DND_TITLE = 'Do not disturb'
13// Under the pointer, what folds turns to the theme's suggestion color with the text drawn on it in
14// the theme's inverse text color: readable in a light and a dark theme alike.
15const LIT_BOX = { backgroundColor: 'suggestion' }
16const LIT_TEXT = { color: 'inverseText', dimColor: false }
17
18const mods = atom({ plugin: 'configuration', key: 'mods' } as const, null)
19const scope = atom({ plugin: 'configuration', key: 'scope' } as const, 'all')
20const saves = atom({ plugin: 'configuration', key: 'saves' } as const, 0)
21const unfolded = atom({ plugin: 'configuration', key: 'unfolded' } as const, {})
22const power = atom({ plugin: 'configuration', key: 'power' } as const, null, { shape: 'low-power/1' })
23
24// Set by dnd once it has read what is on: dnd is installed. Read under dnd's shape.
25const dndActive = atom({ plugin: 'dnd', key: 'active' } as const, null, { shape: 'dnd-active/1' })
26
27// The band's buttons share one row under everything above the prompt, whatever order the mods
28// draw in: each takes that row out of what the mods beneath drew, adds its own button, and sorts
29// them by key (band-1-history, band-2-prs, band-3-reminders, band-4-configuration).
30const BAND_ROW = 'band-buttons'
31
32type Drawn = { type?: string; props?: { key?: string }; children?: unknown[] }
33
34const keyOf = (node: unknown) => (node !== null && typeof node === 'object' ? ((node as Drawn).props?.key ?? '') : '')
35
36const byBandKey = (one: unknown, other: unknown) => keyOf(one).localeCompare(keyOf(other))
37
38const takeBandRow = (tree: unknown): { rest: unknown; buttons: unknown[] } => {
39  if (Array.isArray(tree)) {
40    let buttons: unknown[] = []
41    const rest = tree.map(child => {
42      if (buttons.length > 0) {
43        return child
44      }
45
46      const taken = takeBandRow(child)
47      buttons = taken.buttons
48
49      return taken.rest
50    })
51
52    // The engine reads every child of a drawn tree: the row taken out leaves no hole.
53    return { rest: rest.filter(child => child !== null && child !== undefined), buttons }
54  }
55
56  const node = tree as Drawn | null
57
58  if (node === null || typeof node !== 'object' || !Array.isArray(node.children)) {
59    return { rest: tree, buttons: [] }
60  }
61
62  if (node.props?.key === BAND_ROW) {
63    return { rest: null, buttons: node.children.flat(Infinity) }
64  }
65
66  const taken = takeBandRow(node.children)
67
68  return taken.buttons.length > 0 ? { rest: { ...node, children: taken.rest }, buttons: taken.buttons } : { rest: tree, buttons: [] }
69}
70
71const slashed = (path: string) => path.replace(/\\/g, '/')
72
73const home = async ($: EngineInterface) => slashed((await $.env.get('HOME')) ?? (await $.env.get('USERPROFILE')) ?? '~')
74
75const truncate = (text: string, width: number) =>
76  text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text
77
78// A change for every computer is a /config change, which the private sync shares; one for this
79// computer alone is also written to the sync's machine file, whose settings win over the shared
80// ones at each sync, so the shared value stays for the other computers.
81type Json = Record<string, unknown>
82
83const settingsFile = async ($: EngineInterface) => {
84  const dir = await $.env.get('CLAUDE_CONFIG_DIR')
85
86  return `${dir ? slashed(dir) : `${await home($)}/.claude`}/settings.json`
87}
88
89const readJson = async ($: EngineInterface, path: string): Promise<Json> => {
90  try {
91    const parsed: unknown = JSON.parse(await $.fs.read(path))
92
93    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed) ? (parsed as Json) : {}
94  } catch {
95    return {}
96  }
97}
98
99const objectAt = (value: unknown): Json => (value !== null && typeof value === 'object' && !Array.isArray(value) ? (value as Json) : {})
100
101// This computer's file in the private sync, '' when there is no sync to keep a setting apart in.
102const machineFile = async ($: EngineInterface) => {
103  const sync = `${await home($)}/.claude-sync`
104
105  try {
106    const machine = (await $.fs.read(`${sync}/.machine`)).trim()
107    const file = `${sync}/machines/${machine}.json`
108
109    return machine !== '' && (await $.fs.exists(file)) ? { machine, file } : { machine: '', file: '' }
110  } catch {
111    return { machine: '', file: '' }
112  }
113}
114
115// Settings name a plugin's options by its name, with or without `@<where it comes from>`.
116const configKeyOf = (configs: Json, plugin: string) => Object.keys(configs).find(key => key === plugin || key.startsWith(`${plugin}@`))
117
118const overlayValue = (overlay: Json, plugin: string, field: string) => {
119  const configs = objectAt(objectAt(overlay.settings).pluginConfigs)
120  const key = configKeyOf(configs, plugin)
121
122  return key === undefined ? undefined : objectAt(objectAt(configs[key]).options)[field]
123}
124
125const loadMods = async ($: EngineInterface) => {
126  const { machine, file } = await machineFile($)
127  const overlay = file === '' ? {} : await readJson($, file)
128  // The private sync builds settings.json from its shared settings, then the machine file's over them.
129  const shared = file === '' ? {} : { settings: await readJson($, `${await home($)}/.claude-sync/settings.shared.json`) }
130  const settings = (await $.config.list())
131    .filter(row => row.provider.tier === 'user' && row.key.includes('.'))
132    .map((row): ModSetting => {
133      const plugin = row.key.slice(0, row.key.indexOf('.'))
134      const field = row.key.slice(plugin.length + 1)
135      const isHere = overlayValue(overlay, plugin, field) !== undefined
136      const sharedValue = isHere ? overlayValue(shared, plugin, field) : undefined
137
138      return {
139        key: row.key,
140        plugin,
141        field,
142        label: row.label,
143        ...(row.description ? { description: row.description } : {}),
144        kind: row.kind,
145        value: Array.isArray(row.value) ? [...row.value] : (row.value as ModSetting['value']),
146        ...(row.options ? { options: [...row.options] } : {}),
147        isLocked: row.isLocked,
148        isHere,
149        ...(sharedValue !== undefined ? { shared: sharedValue as ModSetting['value'] } : {}),
150      }
151    })
152
153  await update($, mods, () => ({ settings, machine }))
154}
155
156// What every other computer has for a setting this one keeps apart.
157const sharedText = (setting: ModSetting) =>
158  setting.shared === undefined ? 'the default' : setting.shared === true ? 'on' : setting.shared === false ? 'off' : String(setting.shared)
159
160// Writes the field's value into the machine file, or takes it out (undefined), leaving no empty object behind.
161const writeOverlay = async ($: EngineInterface, file: string, setting: ModSetting, value: ModSetting['value'] | undefined) => {
162  const overlay = await readJson($, file)
163  const settings = objectAt(overlay.settings)
164  const configs = objectAt(settings.pluginConfigs)
165  const local = await readJson($, await settingsFile($))
166  const key = configKeyOf(objectAt(local.pluginConfigs), setting.plugin) ?? configKeyOf(configs, setting.plugin) ?? setting.plugin
167  const entry = objectAt(configs[key])
168  const { [setting.field]: _dropped, ...others } = objectAt(entry.options)
169  const options = value === undefined ? others : { ...others, [setting.field]: value }
170  const { options: _old, ...entryRest } = entry
171  const nextEntry = Object.keys(options).length > 0 ? { ...entryRest, options } : entryRest
172  const { [key]: _was, ...otherConfigs } = configs
173  const nextConfigs = Object.keys(nextEntry).length > 0 ? { ...otherConfigs, [key]: nextEntry } : otherConfigs
174  const { pluginConfigs: _configs, ...settingsRest } = settings
175  const nextSettings = Object.keys(nextConfigs).length > 0 ? { ...settingsRest, pluginConfigs: nextConfigs } : settingsRest
176
177  await $.fs.write(file, `${JSON.stringify({ ...overlay, settings: nextSettings }, null, 2)}\n`)
178}
179
180// For this computer, /config writes first so the machine file names the plugin as settings.json
181// does; for every computer, the machine file lets go first so the sync shares the new value.
182const setMod = async ($: EngineInterface, setting: ModSetting, value: ModSetting['value']) => {
183  const { file } = await machineFile($)
184  const isHere = file !== '' && (await read($, scope)) === 'here'
185
186  try {
187    if (file !== '' && !isHere && setting.isHere) {
188      await writeOverlay($, file, setting, undefined)
189    }
190
191    const { deny } = await $.config.set({ key: setting.key, value })
192
193    if (deny !== undefined) {
194      $.ui.toast(`Could not change ${setting.label}: ${deny}`)
195    } else if (isHere) {
196      await writeOverlay($, file, setting, value)
197    }
198  } catch (error) {
199    $.ui.toast(`Could not change ${setting.label}: ${String(error).split('\n')[0] ?? ''}`)
200  } finally {
201    await loadMods($)
202    await update($, saves, count => count + 1)
203  }
204}
205
206const openPane = async ($: EngineInterface) => {
207  await $.ui.open({ id: PANE, title: TITLE, columns: 64 })
208  await loadMods($)
209}
210
211// Low power mode, for every part of the kit that fetches by itself: `on`, `off`, or `on battery`
212// (while the computer runs on its battery or in its low power mode). The mods read it under the
213// shape `low-power/1`; scripts (pr-watch, the status line) from ~/.claude/.low-power.json.
214const POWER_FILE = '.low-power.json'
215const POWER_EVERY_MS = 60_000
216// A PowerShell call costs a second: Windows is asked less often.
217const POWER_EVERY_WINDOWS_MS = 5 * 60_000
218const POWER_KEPT_MS = 10 * 60_000
219const LINUX_MAINS = ['AC', 'ACAD', 'AC0', 'ADP0', 'ADP1']
220
221type PowerWay = 'pmset' | 'linux' | 'windows' | 'none'
222let powerWay: PowerWay | undefined
223
224const ran = async ($: EngineInterface, argv: string[]) => {
225  try {
226    const result = await $.process.run(argv, { timeoutMs: 10_000 })
227
228    return result.exitCode === 0 ? result.stdout : undefined
229  } catch {
230    return undefined
231  }
232}
233
234const linuxMains = async ($: EngineInterface) => {
235  for (const name of LINUX_MAINS) {
236    const online = await $.fs.read(`/sys/class/power_supply/${name}/online`).catch(() => undefined)
237
238    if (online !== undefined) {
239      return online.trim()
240    }
241  }
242
243  return undefined
244}
245
246// Whether the computer runs on its battery or in its low power mode; false when it cannot tell.
247const onBattery = async ($: EngineInterface) => {
248  if (powerWay === undefined || powerWay === 'pmset') {
249    const battery = await ran($, ['pmset', '-g', 'batt'])
250
251    if (battery !== undefined) {
252      powerWay = 'pmset'
253      const settings = (await ran($, ['pmset', '-g'])) ?? ''
254
255      return battery.includes("'Battery Power'") || /lowpowermode\s+1/.test(settings)
256    }
257  }
258
259  if (powerWay === undefined || powerWay === 'linux') {
260    const online = await linuxMains($)
261
262    if (online !== undefined) {
263      powerWay = 'linux'
264
265      return online === '0'
266    }
267  }
268
269  if (powerWay === undefined || powerWay === 'windows') {
270    const status = await ran($, ['powershell', '-NoProfile', '-NonInteractive', '-Command', '(Get-CimInstance Win32_Battery).BatteryStatus'])
271
272    if (status !== undefined) {
273      powerWay = 'windows'
274
275      // 1: the battery is discharging, on battery power.
276      return status.trim().split(/\s+/).includes('1')
277    }
278  }
279
280  powerWay = 'none'
281
282  return false
283}
284
285let powerSetting = 'on battery'
286let powerWritten = { text: '', at: 0 }
287
288const checkPower = async ($: EngineInterface) => {
289  const isLow = powerSetting === 'on' || (powerSetting === 'on battery' && (await onBattery($)))
290  const now = await $.clock.now()
291  await update($, power, () => ({ setting: powerSetting, isLow }))
292  const text = JSON.stringify({ setting: powerSetting, lowPower: isLow })
293
294  // Written when it changes, and now and then so the scripts know it is still checked.
295  if (text !== powerWritten.text || now - powerWritten.at >= POWER_KEPT_MS / 2) {
296    const dir = await $.env.get('CLAUDE_CONFIG_DIR')
297    const path = `${dir ? slashed(dir) : `${await home($)}/.claude`}/${POWER_FILE}`
298    await $.fs
299      .write(path, `${JSON.stringify({ setting: powerSetting, lowPower: isLow, at: new Date(now).toISOString() })}\n`)
300      .then(() => {
301        powerWritten = { text, at: now }
302      })
303      .catch(() => undefined)
304  }
305}
306
307let powerTicking: { cancel: () => void } | undefined
308
309const startPower = async ($: EngineInterface) => {
310  powerTicking?.cancel()
311  await checkPower($)
312  powerTicking = $.clock.every(powerWay === 'windows' ? POWER_EVERY_WINDOWS_MS : POWER_EVERY_MS, () => void checkPower($).catch(() => undefined))
313}
314
315let loadAsked = false
316
317export const register: Register = (on, options) => {
318  powerSetting = typeof options.lowPower === 'string' ? options.lowPower : 'on battery'
319
320  on('session.start', async ($, e, next) => {
321    await $.command.register({ name: COMMAND, description: "Open the Configuration pane: every mod's settings" }).catch(() => undefined)
322    void startPower($).catch(() => undefined)
323
324    return next(e)
325  })
326
327  on('command.run', { command: COMMAND }, async $ => {
328    await openPane($)
329
330    return { text: 'Configuration pane opened.' }
331  })
332
333  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
334    const beneath = await next(e)
335
336    // A reload (a setting changed) brings no session start: the power check starts again here.
337    if (powerTicking === undefined) {
338      powerTicking = { cancel: () => undefined }
339      void startPower($).catch(() => undefined)
340    }
341
342    if (e.props.hasSurvey || e.props.view.agentId !== undefined) {
343      return beneath
344    }
345
346    const { Box, Button } = $.ui.resolve(e)
347    const { rest, buttons } = takeBandRow(beneath)
348    const mine = (
349      <Box key="band-4-configuration" flexDirection="row">
350        <Button key="configuration" label={TITLE} dimColor onPress={() => void openPane($)} />
351      </Box>
352    )
353
354    return (
355      <Box flexDirection="column">
356        {rest as never}
357        <Box key={BAND_ROW} flexDirection="row" gap={2}>
358          {[...buttons, mine].sort(byBandKey) as never}
359        </Box>
360      </Box>
361    )
362  })
363
364  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
365    const { Box, Button, Input, Text } = $.ui.resolve(e)
366    const shown = await read($, mods)
367    const where = await read($, scope)
368    const saved = await read($, saves)
369    const open = await read($, unfolded)
370    const hasDnd = (await read($, dndActive)) !== null
371    const width = Math.max(30, e.props.bodyColumns - 2)
372
373    // Read on the first draw after a load or reload: opened by another mod's button (dnd's), or kept
374    // open while a mod brought new settings.
375    if (!loadAsked) {
376      loadAsked = true
377      void loadMods($)
378    }
379
380    // One setting: a press flips a toggle or moves a choice on; a text or a number is typed.
381    const settingRow = (setting: ModSetting) => {
382      const title = `${setting.label}${setting.isHere ? ' (this computer)' : ''}`
383
384      if (setting.isLocked) {
385        return <Text key={`setting-${setting.key}`} dimColor>{truncate(`${title}: ${String(setting.value)} (locked)`, width - 4)}</Text>
386      }
387
388      if (setting.kind === 'boolean') {
389        return (
390          <Box key={`setting-${setting.key}`} flexDirection="row" hover={LIT_BOX}>
391            <Button
392              key={`set-${setting.key}`}
393              label={`${setting.value === true ? '[x]' : '[ ]'} ${truncate(title, width - 8)}`}
394              plain
395              hover={LIT_TEXT}
396              onPress={() => void setMod($, setting, setting.value !== true)}
397            />
398          </Box>
399        )
400      }
401
402      if (setting.kind === 'choice') {
403        const options = setting.options ?? []
404        const following = options[(options.indexOf(String(setting.value)) + 1) % Math.max(1, options.length)] ?? ''
405
406        return (
407          <Box key={`setting-${setting.key}`} flexDirection="row" hover={LIT_BOX}>
408            <Button
409              key={`set-${setting.key}`}
410              label={truncate(`${title}: ${String(setting.value)}`, width - 4)}
411              plain
412              hover={LIT_TEXT}
413              onPress={() => void setMod($, setting, following)}
414            />
415          </Box>
416        )
417      }
418
419      // The field keeps what was typed until it is drawn anew: a key per save draws the saved value
420      // again, even when it did not change. A number that does not read as one is not saved.
421      const save = (typed: string) => {
422        if (setting.kind !== 'number') {
423          void setMod($, setting, typed)
424        } else if (typed.trim() !== '' && Number.isFinite(Number(typed))) {
425          void setMod($, setting, Number(typed))
426        } else {
427          void update($, saves, count => count + 1)
428        }
429      }
430
431      return (
432        <Input
433          key={`set-${setting.key}-${saved}`}
434          label={`${truncate(title, Math.floor(width / 2))} `}
435          value={String(setting.value)}
436          submitLabel="save"
437          onSubmit={save}
438        />
439      )
440    }
441
442    const toggle = (key: string) => void update($, unfolded, all => ({ ...all, [key]: !(all[key] ?? true) }))
443
444    const header = (
445      <Box flexDirection="row" justifyContent="space-between" marginBottom={1}>
446        <Text bold>Mod settings</Text>
447        {hasDnd && <Button key="open-dnd" label={`${DND_TITLE} ›`} dimColor onPress={() => void $.ui.open({ id: DND_PANE, title: DND_TITLE, columns: 64 })} />}
448      </Box>
449    )
450
451    if (shown === null) {
452      return (
453        <Box flexDirection="column">
454          {header}
455          <Text dimColor>Loading…</Text>
456        </Box>
457      )
458    }
459
460    const plugins = [...new Set(shown.settings.map(setting => setting.plugin))]
461
462    return (
463      <Box flexDirection="column">
464        {header}
465        {shown.machine !== '' ? (
466          <Box flexDirection="row" gap={1}>
467            <Text>Changes apply to</Text>
468            <Button key="scope-all" label="all computers" dimColor={where !== 'all'} onPress={() => void update($, scope, () => 'all')} />
469            <Button key="scope-here" label={`this computer only (${shown.machine})`} dimColor={where !== 'here'} onPress={() => void update($, scope, () => 'here')} />
470          </Box>
471        ) : (
472          <Text dimColor>Changes apply to this computer: there is no private sync to share them.</Text>
473        )}
474        {plugins.length === 0 && <Text dimColor>No mod has settings.</Text>}
475        {plugins.map(plugin => {
476          const key = `mod|${plugin}`
477          const isOpen = open[key] ?? true
478          const settings = shown.settings.filter(setting => setting.plugin === plugin)
479
480          return (
481            <Box key={key} flexDirection="column" marginTop={1}>
482              <Box flexDirection="row" hover={LIT_BOX}>
483                <Button key={`fold-${key}`} label={`${isOpen ? '▾' : '▸'} ${truncate(`${plugin} (${settings.length})`, width - 4)}`} plain hover={LIT_TEXT} onPress={() => toggle(key)} />
484              </Box>
485              {isOpen && (
486                <Box flexDirection="column" paddingLeft={2}>
487                  {settings.map(setting => (
488                    <Box key={`row-${setting.key}`} flexDirection="column">
489                      {settingRow(setting)}
490                      {setting.isHere && <Text dimColor>{truncate(`  used here instead of all computers' value: ${sharedText(setting)}`, width - 4)}</Text>}
491                    </Box>
492                  ))}
493                </Box>
494              )}
495            </Box>
496          )
497        })}
498      </Box>
499    )
500  })
501}
502

1/** One mod setting (a plugin's userConfig field) as the Mods list shows it. */
2export type ModSetting = {
3  /** `<plugin>.<field>`, as `$.config.set` takes it. */
4  key: string
5  plugin: string
6  field: string
7  label: string
8  description?: string
9  kind: 'boolean' | 'choice' | 'text' | 'number'
10  value: boolean | string | number | string[]
11  options?: string[]
12  isLocked: boolean
13  /** Kept for this computer alone, in the private sync's machine file, over the shared value. */
14  isHere: boolean
15  /** With isHere, the value every other computer has (the private sync's shared settings); absent: the default. */
16  shared?: boolean | string | number | string[]
17}
18
19/** Every user mod's settings, and this computer's name in the private sync ('' with none). */
20export type ModsData = { settings: ModSetting[]; machine: string }
21
22/** Low power mode: what the user chose, and whether it slows the kit now. */
23export type LowPower = { setting: string; isLow: boolean }
24
25/** What dnd shares under the shape `dnd-active/1`; only whether it is set is read here. */
26export type DndActiveSeen = Record<string, unknown>
27
28declare module 'claude-code' {
29  interface PluginState {
30    configuration: {
31      /** The settings listed; null before they are first read. */
32      mods: ModsData | null
33      /** Where a change goes: every computer, or this one alone. */
34      scope: 'all' | 'here'
35      /** Settings saved, counted: a typed field is drawn anew with each. */
36      saves: number
37      /** The mods folded (`mod|<plugin>`: false), open by default. */
38      unfolded: Record<string, boolean>
39      /**
40       * Low power mode as the other mods read it, under the shape `low-power/1`: the setting (`on`,
41       * `off`, `on battery`) and whether it is on now. null before the first check.
42       */
43      power: Shaped<LowPower | null>
44    }
45    dnd: {
46      active: Shaped<DndActiveSeen | null>
47    }
48  }
49}
50