recording-mode

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { Settings } from '../types'
5import { HELP, hint, mask, maskDeep, policyText } from './lib'
6import type { MaskOptions } from './lib'
7
8const DEFAULTS: Settings = { isOn: false, isStrict: false }
9const settings = atom({ plugin: 'recording-mode', key: 'settings' } as const, DEFAULTS)
10
11const isSettings = (v: unknown): v is Settings =>
12  typeof v === 'object' &&
13  v !== null &&
14  typeof (v as Settings).isOn === 'boolean' &&
15  typeof (v as Settings).isStrict === 'boolean'
16
17const loadWords = async ($: EngineInterface): Promise<string[]> => {
18  const raw = await $.store.get('words')
19
20  return Array.isArray(raw) ? raw.filter((w): w is string => typeof w === 'string') : []
21}
22
23/** The masking options, or null while recording mode is off. */
24const optionsOf = async ($: EngineInterface): Promise<MaskOptions | null> => {
25  const cfg = ((await read($, settings)) as Settings | undefined) ?? DEFAULTS
26  if (!cfg.isOn) return null
27
28  return { isStrict: cfg.isStrict, words: await loadWords($) }
29}
30
31function show($: EngineInterface, cfg: Settings) {
32  $.ui.status(cfg.isOn ? (cfg.isStrict ? '● REC strict' : '● REC') : undefined)
33}
34
35async function apply($: EngineInterface, cfg: Settings) {
36  await update($, settings, () => cfg)
37  await $.store.set('settings', cfg)
38  show($, cfg)
39}
40
41export const register: Register = on => {
42  on('session.start', async ($, e, next) => {
43    const saved = await $.store.get('settings')
44    if (isSettings(saved)) {
45      await update($, settings, () => saved)
46      if (saved.isOn) {
47        show($, saved)
48        $.ui.toast('Recording mode is still ON')
49      }
50    }
51    await $.command.register({
52      name: 'rec',
53      description: 'Recording mode: mask secrets on screen',
54      argumentHint: 'strict | off | hide <word> | unhide <word> | list | test <text>',
55    })
56
57    return next(e)
58  })
59
60  on('prompt.compose', async ($, e, next) => {
61    const result = await next(e)
62    const cfg = ((await read($, settings)) as Settings | undefined) ?? DEFAULTS
63    if (!cfg.isOn) return result
64
65    return {
66      sections: [
67        ...result.sections,
68        { id: 'recording-mode:policy', text: policyText(cfg.isStrict), scope: 'session' as const },
69      ],
70    }
71  })
72
73  on('command.run', { command: 'rec' }, async ($, e) => {
74    const [head = '', ...rest] = e.args.trim().split(/\s+/)
75    const verb = head.toLowerCase()
76    const arg = rest.join(' ').trim()
77    const cfg = ((await read($, settings)) as Settings | undefined) ?? DEFAULTS
78
79    if (verb === '' || verb === 'on') {
80      const next: Settings = verb === '' && cfg.isOn ? { ...cfg, isOn: false } : { isOn: true, isStrict: false }
81      await apply($, next)
82      $.ui.toast(next.isOn ? 'Recording mode ON' : 'Recording mode OFF')
83
84      return { text: next.isOn ? 'Recording mode is on.' : 'Recording mode is off.' }
85    }
86    if (verb === 'strict') {
87      await apply($, { isOn: true, isStrict: true })
88      $.ui.toast('Recording mode ON (strict)')
89
90      return { text: 'Recording mode is on, strict: amounts and home paths hidden too.' }
91    }
92    if (verb === 'off') {
93      await apply($, { ...cfg, isOn: false })
94      $.ui.toast('Recording mode OFF')
95
96      return { text: 'Recording mode is off.' }
97    }
98    if (verb === 'hide' || verb === 'unhide') {
99      if (arg === '') return { text: `Usage: /rec ${verb} <word>` }
100      const words = await loadWords($)
101      const has = words.some(w => w.toLowerCase() === arg.toLowerCase())
102      if (verb === 'hide') {
103        if (!has) await $.store.set('words', [...words, arg])
104
105        return { text: `Hiding ${hint(arg)} (${has ? words.length : words.length + 1} private words).` }
106      }
107      await $.store.set('words', words.filter(w => w.toLowerCase() !== arg.toLowerCase()))
108
109      return { text: has ? `Unhid ${hint(arg)}.` : `${hint(arg)} was not hidden.` }
110    }
111    if (verb === 'list') {
112      const words = await loadWords($)
113
114      return {
115        text: words.length === 0 ? 'No private words.' : `${words.length} private words: ${words.map(hint).join(' ')}`,
116      }
117    }
118    if (verb === 'test') {
119      const words = await loadWords($)
120      // Preview shows what strict-or-not would look like for the current setting, masked even while off.
121      const out = mask(e.args.trim().slice(head.length).trim(), { isStrict: cfg.isStrict, words })
122
123      return { text: `Masked: ${out}` }
124    }
125
126    return { text: HELP }
127  })
128
129  // Display only: each site rewrites the props the engine draws, never what the model read.
130  on('ui.render', { component: 'UserMessage' }, async ($, e, next) => {
131    const o = await optionsOf($)
132    if (o === null) return next(e)
133
134    return next({ ...e, props: { ...e.props, text: mask(e.props.text, o) } })
135  })
136
137  on('ui.render', { component: 'AssistantMessage' }, async ($, e, next) => {
138    const o = await optionsOf($)
139    if (o === null) return next(e)
140
141    return next({ ...e, props: { ...e.props, text: mask(e.props.text, o) } })
142  })
143
144  on('ui.render', { component: 'CommandOutput' }, async ($, e, next) => {
145    const o = await optionsOf($)
146    if (o === null) return next(e)
147
148    return next({ ...e, props: { ...e.props, text: mask(e.props.text, o) } })
149  })
150
151  on('ui.render', { component: 'ToolUse' }, async ($, e, next) => {
152    const o = await optionsOf($)
153    if (o === null) return next(e)
154
155    return next({ ...e, props: { ...e.props, input: maskDeep(e.props.input, o) } })
156  })
157
158  on('ui.render', { component: 'ToolResult' }, async ($, e, next) => {
159    const o = await optionsOf($)
160    if (o === null) return next(e)
161
162    return next({ ...e, props: { ...e.props, output: maskDeep(e.props.output, o) } })
163  })
164
165  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
166    const cfg = ((await read($, settings)) as Settings | undefined) ?? DEFAULTS
167    if (e.props.hasSurvey || !cfg.isOn) return next(e)
168
169    const { Box, Text } = $.ui.resolve(e)
170    const chip = (
171      <Text bold color="#b8aece" backgroundColor="#3b2160">
172        {cfg.isStrict ? '  STRICT ● ' : '     REC ● '}
173      </Text>
174    )
175    const below = await next(e)
176
177    return below ? (
178      <Box flexDirection="column">
179        {chip}
180        {below}
181      </Box>
182    ) : (
183      chip
184    )
185  })
186}
187

1export type MaskOptions = { isStrict: boolean; words: readonly string[] }
2
3export const OFF_SCREEN = "Recording mode is on, so I'll keep that off screen"
4
5export const POLICY = [
6  'Recording mode is on: the user is screen-recording this session.',
7  'Never print API keys, tokens, passwords, secret environment values, email addresses, phone numbers or the user\'s private words, whether they come from files, tool output or the user.',
8  'Refer to them generically ("your API key", "the email address in the config") and, when you hold back something the user asked for, say: "' + OFF_SCREEN + '".',
9  'Do not echo such values inside commands or code you show either; use placeholders.',
10].join('\n')
11
12const STRICT_POLICY = ' Also keep dollar amounts and home-folder paths off screen.'
13
14export const policyText = (isStrict: boolean): string => (isStrict ? POLICY + STRICT_POLICY : POLICY)
15
16const escape = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
17
18// Order matters: key shapes first so a token is never half-eaten by a later rule.
19const KEY_RULES: readonly (readonly [RegExp, string])[] = [
20  [/\bsk-[A-Za-z0-9_-]{16,}/g, '[key]'],
21  [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, '[key]'],
22  [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[key]'],
23  [/\bxox[abposr]-[A-Za-z0-9-]{10,}/g, '[key]'],
24  [/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/g, 'Bearer [key]'],
25  [
26    /^([ \t]*(?:export[ \t]+)?[A-Za-z_][A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL)[A-Za-z0-9_]*[ \t]*=[ \t]*)\S.*$/gim,
27    '$1[key]',
28  ],
29]
30
31const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g
32// Needs a separator or a leading plus, so commit ids and plain numbers stay.
33const PHONE = /(?<![\w.])(?:\+\d{1,3}[\s.-]?)?(?:\(\d{3}\)\s?|\d{3}[\s.-])\d{3}[\s.-]\d{4}(?![\w])|(?<![\w.])\+\d{1,3}[\s.-]\d{2,4}[\s.-]\d{3,4}(?:[\s.-]\d{2,4})?(?![\w])/g
34
35const MONEY = /[$€£]\s?\d[\d,]*(?:\.\d+)?(?:\s?[kKmMbB]\b)?/g
36const HOME = /(?:\/Users\/|\/home\/|[A-Za-z]:\\Users\\)[^\s/\\:"'`]+/g
37
38export function mask(text: string, o: MaskOptions): string {
39  let out = text
40  for (const [re, to] of KEY_RULES) out = out.replace(re, to)
41  out = out.replace(EMAIL, '[email]').replace(PHONE, '[phone]')
42  for (const w of o.words) {
43    if (w === '') continue
44    out = out.replace(new RegExp(`(?<![A-Za-z0-9])${escape(w)}(?![A-Za-z0-9])`, 'gi'), '[private]')
45  }
46  if (o.isStrict) out = out.replace(MONEY, '[amount]').replace(HOME, '[home]')
47
48  return out
49}
50
51/** Masks every string in a JSON-like value, leaving shape and other types alone. */
52export function maskDeep(v: unknown, o: MaskOptions): unknown {
53  if (typeof v === 'string') return mask(v, o)
54  if (Array.isArray(v)) return v.map(x => maskDeep(x, o))
55  if (typeof v === 'object' && v !== null) {
56    const out: Record<string, unknown> = {}
57    for (const [k, x] of Object.entries(v)) if (x !== undefined) out[k] = maskDeep(x, o)
58
59    return out
60  }
61
62  return v
63}
64
65/** First letter and dots, so a list never shows the word itself. */
66export const hint = (w: string): string => `${[...w][0] ?? ''}•••`
67
68export const HELP = [
69  '/rec            toggle recording mode',
70  '/rec strict     on, and also hide $ amounts and home-folder paths',
71  '/rec off        turn off',
72  '/rec hide <w>   mask a private word',
73  '/rec unhide <w> stop masking it',
74  '/rec list       count and first letters',
75  '/rec test <t>   preview masking',
76].join('\n')
77

1export type Settings = { isOn: boolean; isStrict: boolean }
2
3declare module 'claude-code' {
4  interface PluginState {
5    // Private words are never kept here, only in $.store.
6    'recording-mode': { settings: Settings }
7  }
8}
9