bandeja-mensajes

1import type { EngineInterface, Register } from 'claude-code'
2
3import type { Mensaje } from '../types'
4import { clock, convention, desktopCandidates, fileName, joinPath, parseDrafts } from './mensajes'
5import { loadConfig } from './orca-config'
6import type { Host } from './orca-config'
7
8const PANE = 'mensajes'
9const CAP = 50
10const items = { plugin: 'bandeja-mensajes', key: 'items' } as const
11
12const load = async ($: EngineInterface): Promise<Mensaje[]> => {
13  const kept = await $.store.get('mensajes')
14
15  return Array.isArray(kept) ? (kept as Mensaje[]) : []
16}
17
18const keep = async ($: EngineInterface, list: Mensaje[]): Promise<void> => {
19  await $.store.set('mensajes', list)
20  await $.state.set(items, list)
21}
22
23// The engine's `$` cannot cross an import: the config module gets these closures instead.
24const hostOf = ($: EngineInterface): Host => ({
25  home: async () => (await $.env.get('USERPROFILE')) ?? (await $.env.get('HOME')),
26  exists: path => $.fs.exists(path),
27  read: path => $.fs.read(path),
28  git: argv => $.process.run(argv, { timeoutMs: 10_000 }),
29  now: () => $.clock.now(),
30})
31
32// The Desktop folder: OneDrive's when it exists (it is the redirected one), else the plain one.
33const desktop = async ($: EngineInterface): Promise<string | undefined> => {
34  const home = (await $.env.get('USERPROFILE')) ?? (await $.env.get('HOME'))
35  if (home === undefined || home === '') {
36    return undefined
37  }
38  for (const path of desktopCandidates(home)) {
39    if (await $.fs.exists(path)) {
40      return path
41    }
42  }
43
44  return undefined
45}
46
47export const register: Register = on => {
48  on('session.start', async ($, e, next) => {
49    await $.command.register({
50      name: 'mensajes',
51      description: 'Abre la bandeja con los mensajes que redactó Claude para mandar',
52    })
53    await $.state.set(items, await load($))
54
55    return next(e)
56  })
57
58  on('command.run', { command: 'mensajes' }, async $ => {
59    await $.state.set(items, await load($))
60    await $.ui.open({ id: PANE, title: 'Bandeja de mensajes' })
61
62    return { text: 'Bandeja de mensajes abierta.' }
63  })
64
65  on('prompt.compose', async ($, e, next) => {
66    const composed = await next(e)
67    const configured = (await loadConfig(hostOf($))).mensajes?.destinatarios
68    const recipients = Array.isArray(configured) ? configured.filter(one => typeof one === 'string') : []
69
70    return {
71      sections: [
72        ...composed.sections,
73        { id: 'bandeja-mensajes:convencion', text: convention(recipients), scope: 'session' as const },
74      ],
75    }
76  })
77
78  on('turn.complete', async ($, e, next) => {
79    const drafts = e.agentId === undefined ? parseDrafts(e.answer) : []
80    if (drafts.length > 0) {
81      const now = await $.clock.now()
82      let list = await load($)
83      ;[...drafts].reverse().forEach((draft, i) => {
84        const isKnown = list.some(one => one.to === draft.to && one.text === draft.text)
85        list = list.filter(one => !(one.to === draft.to && one.text === draft.text))
86        list.unshift({ id: `${now}-${i}`, to: draft.to, text: draft.text, at: now })
87        if (!isKnown) {
88          $.ui.toast(
89            draft.to === ''
90              ? 'Mensaje guardado en la bandeja'
91              : `Mensaje para ${draft.to} guardado en la bandeja`,
92          )
93        }
94      })
95      await keep($, list.slice(0, CAP))
96    }
97
98    return next(e)
99  })
100
101  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
102    const { Box, Button, Text } = $.ui.resolve(e)
103    const { value: list = [] } = await $.state.get(items)
104    if (list.length === 0) {
105      return <Text dimColor>Todavía no hay mensajes. Cuando Claude redacte uno, aparece acá.</Text>
106    }
107
108    return (
109      <Box flexDirection="column" gap={1}>
110        {list.map(one => (
111          <Box key={`row:${one.id}`} flexDirection="column">
112            <Text bold>
113              {one.to === '' ? 'Sin destinatario' : one.to} · {clock(one.at)}
114            </Text>
115            <Text>{one.text}</Text>
116            <Box gap={2}>
117              <Button
118                key={`copy:${one.id}`}
119                label="Copiar"
120                onPress={async press => {
121                  const copied = await $.ui.copy({ text: one.text, surface: press.surface })
122                  $.ui.toast(copied.isCopied ? 'Copiado' : 'No pude copiar: probá seleccionando el texto')
123                }}
124              />
125              <Button
126                key={`save:${one.id}`}
127                label="Guardar en el Escritorio"
128                onPress={async () => {
129                  const folder = await desktop($)
130                  if (folder === undefined) {
131                    $.ui.toast('No encontré la carpeta Escritorio')
132                    return
133                  }
134                  const path = joinPath(folder, fileName(one.to, one.at))
135                  try {
136                    await $.fs.write(path, one.text)
137                    $.ui.toast(`Guardado en ${path}`)
138                  } catch {
139                    $.ui.toast(`No pude guardar en ${path}`)
140                  }
141                }}
142              />
143            </Box>
144          </Box>
145        ))}
146      </Box>
147    )
148  })
149}
150

1// Pure helpers for the outgoing-message tray.
2
3export type Draft = { to: string; text: string }
4
5// ```mensaje Ana \n ... \n``` (a longer fence is closed by the same length).
6const FENCE = /^(`{3,})mensaje[ \t]*([^\n`]*)\n([\s\S]*?)\n\1[ \t]*$/gm
7
8export const parseDrafts = (answer: string): Draft[] =>
9  [...answer.matchAll(FENCE)]
10    .map(match => ({ to: (match[2] ?? '').trim(), text: (match[3] ?? '').trim() }))
11    .filter(draft => draft.text !== '')
12
13// The system-prompt section. Recipients come from the config (`mensajes.destinatarios`); with none
14// configured the convention stays generic and any name after `mensaje` is captured.
15export const convention = (recipients: readonly string[] = []): string => {
16  const names = recipients.map(name => name.trim()).filter(name => name !== '')
17  const list = names.length === 1 ? names[0] : `${names.slice(0, -1).join(', ')} o ${names.at(-1)}`
18  const who = names.length === 0 ? 'a otra persona' : `a otra persona (${list})`
19  const example = names[0] ?? 'Nombre'
20
21  return [
22    `Cuando redactes un mensaje que el usuario va a mandar ${who},`,
23    'ponelo siempre en un bloque de código cuya info string sea `mensaje` seguida del destinatario, por ejemplo:',
24    '```mensaje ' + example,
25    'Hola, ...',
26    '```',
27    'Un bloque por mensaje; el contenido del bloque es exactamente el texto a enviar.',
28  ].join('\n')
29}
30
31const pad = (n: number): string => String(n).padStart(2, '0')
32
33export const stamp = (at: number): string => {
34  const d = new Date(at)
35
36  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`
37}
38
39export const clock = (at: number): string => {
40  const d = new Date(at)
41
42  return `${pad(d.getDate())}/${pad(d.getMonth() + 1)} ${pad(d.getHours())}:${pad(d.getMinutes())}`
43}
44
45export const fileName = (to: string, at: number): string => {
46  const who = to.replace(/[\\/:*?"<>|]/g, '').trim().replace(/\s+/g, '-')
47
48  return `mensaje-${who === '' ? 'sin-destinatario' : who}-${stamp(at)}.txt`
49}
50
51// Desktop candidates under a home dir, joined with the separator the home already uses.
52export const desktopCandidates = (home: string): string[] => {
53  const sep = home.includes('\\') ? '\\' : '/'
54
55  return [`${home}${sep}OneDrive${sep}Desktop`, `${home}${sep}Desktop`]
56}
57
58export const joinPath = (folder: string, name: string): string =>
59  `${folder}${folder.includes('\\') ? '\\' : '/'}${name}`
60

1// Config resolution shared by the orca-stack mods. A plugin can only import files of its own folder,
2// so this file is copied verbatim into each mod that needs it (hooks/orca-config.ts); the repo's
3// tests fail if a copy drifts from this one (edit shared/orca-config.ts, then run `npm run sync-shared`).
4//
5// Three layers, later ones override earlier ones:
6//   1. ~/.orca-stack/config.json        (personal)
7//   2. <repo>/.orca-stack.json          (committed project rules)
8//   3. <repo>/.orca-stack.local.json    (gitignored, local/sensitive)
9// <repo> is the main checkout, even when the session runs inside a git worktree.
10
11export type BlockRule = { agente: string; hasta: string; motivo?: string }
12
13export type StackConfig = {
14  humano?: string
15  mensajes?: { destinatarios?: string[] }
16  despacho?: { script?: string; revisar?: string }
17  riesgo?: string[] // path globs whose change needs a second review before merging (pi, or two other model families when pi wrote it)
18  agentes?: {
19    usa?: string[]
20    preguntarAntes?: string[]
21    modelos?: Record<string, unknown>
22    pi?: { perfil?: string; claudeConfigDir?: string } // perfil: gentle-pi profile name, or "preguntar" (the default)
23  }
24  guardia?: {
25    bloquear?: BlockRule[]
26    modeloClaude?: string
27  }
28}
29
30// Model families. Two agents whose models share a family share blind spots: one does not review the other, and
31// they do not count as two independent reviews. The family comes from the model in `agentes.modelos` (the one the
32// launcher passes with --model): its name, without the provider prefix, against `patterns`, in order. An agent
33// with no model takes `defaults`; pi is `fixed`, because its launcher never passes a model. A model that matches
34// no pattern has no family: nothing is proved about it.
35// The literal between the markers is JSON: src/despacho.mjs keeps the same one, and test/units.test.mjs compares them.
36// BEGIN FAMILIES
37export const FAMILIES = {
38  "agents": ["claude", "agy", "codex", "codex-cc", "pi"],
39  "fixed": { "pi": "claude" },
40  "defaults": { "claude": "claude", "codex": "gpt", "agy": "gemini" },
41  "patterns": [
42    ["claude", "^(claude|opus|sonnet|haiku|fable)"],
43    ["gpt", "^(gpt|codex|o\\d)"],
44    ["gemini", "^gemini"],
45    ["glm", "^glm"]
46  ]
47} as const
48// END FAMILIES
49
50const isPlain = (value: unknown): value is Record<string, unknown> =>
51  value !== null && typeof value === 'object' && !Array.isArray(value)
52
53export const familyOfModel = (model: string): string | undefined => {
54  const name = model.trim().toLowerCase().split('/').pop() ?? ''
55
56  return FAMILIES.patterns.find(([, pattern]) => new RegExp(pattern).test(name))?.[0]
57}
58
59// agentes.modelos.<agent>: "model", { modelo, esfuerzo } or { implementar: {...}, revisar: {...} } (as src/despacho.mjs).
60export const modelFor = (config: StackConfig, agent: string, mode: 'ticket' | 'review'): string | undefined => {
61  let entry = config.agentes?.modelos?.[agent]
62  if (isPlain(entry) && (entry['implementar'] !== undefined || entry['revisar'] !== undefined)) {
63    entry = entry[mode === 'review' ? 'revisar' : 'implementar']
64  }
65  const model = typeof entry === 'string' ? entry : isPlain(entry) ? entry['modelo'] : undefined
66
67  return typeof model === 'string' && model.trim() !== '' ? model.trim() : undefined
68}
69
70// The family `agent` runs on to implement ('ticket') or to review; `model` is the configured one, for messages.
71export const familyOf = (
72  config: StackConfig,
73  agent: string,
74  mode: 'ticket' | 'review',
75): { family: string | undefined; model: string | undefined } => {
76  const fixed = (FAMILIES.fixed as Record<string, string>)[agent]
77  if (fixed !== undefined) {
78    return { family: fixed, model: undefined }
79  }
80  const model = modelFor(config, agent, mode)
81
82  return { family: model === undefined ? (FAMILIES.defaults as Record<string, string>)[agent] : familyOfModel(model), model }
83}
84
85// "2026-10-29" -> local midnight of that day; an agent is blocked while now < that instant.
86export const parseUntil = (date: string): number | undefined => {
87  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date.trim())
88  if (match === null) {
89    return undefined
90  }
91  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])]
92  const at = new Date(year, month - 1, day)
93  // Round trip: 2026-02-30 would silently become 2026-03-02.
94  if (at.getFullYear() !== year || at.getMonth() !== month - 1 || at.getDate() !== day) {
95    return undefined
96  }
97
98  return at.getTime()
99}
100
101// Why `agent` cannot be dispatched now, or undefined. A rule with a bad date stops it too: a block must not
102// vanish because of a typo.
103export const blockOf = (config: StackConfig, agent: string, now: number): string | undefined => {
104  for (const rule of config.guardia?.bloquear ?? []) {
105    if (typeof rule?.agente !== 'string' || rule.agente.toLowerCase() !== agent.toLowerCase()) {
106      continue
107    }
108    const until = typeof rule.hasta === 'string' ? parseUntil(rule.hasta) : undefined
109    if (until === undefined) {
110      return `La regla guardia.bloquear de ${agent} tiene una fecha "hasta" que no es AAAA-MM-DD (${String(rule.hasta)}): corregila antes de despacharlo.`
111    }
112    if (now < until) {
113      return typeof rule.motivo === 'string' && rule.motivo.trim() !== '' ? rule.motivo : `${agent} está bloqueado hasta el ${rule.hasta}.`
114    }
115  }
116
117  return undefined
118}
119
120// Plain objects merge key by key; anything else (arrays included) is replaced by the later layer.
121const mergePlain = (...layers: unknown[]): Record<string, unknown> => {
122  const out: Record<string, unknown> = {}
123  for (const layer of layers) {
124    if (!isPlain(layer)) {
125      continue
126    }
127    for (const [key, value] of Object.entries(layer)) {
128      const before = out[key]
129      out[key] = isPlain(value) && isPlain(before) ? mergePlain(before, value) : value
130    }
131  }
132
133  return out
134}
135
136// One exception: `guardia.bloquear` adds up across the layers, so a block in one layer cannot be dropped by another.
137export const mergeConfig = (...layers: unknown[]): StackConfig => {
138  const out = mergePlain(...layers) as StackConfig
139  const rules = layers.flatMap(layer => {
140    const guardia = isPlain(layer) ? layer['guardia'] : undefined
141    const list = isPlain(guardia) ? guardia['bloquear'] : undefined
142
143    return Array.isArray(list) ? (list as BlockRule[]) : []
144  })
145  if (rules.length > 0) {
146    out.guardia = { ...out.guardia, bloquear: rules }
147  }
148
149  return out
150}
151
152export const parseJson = (text: string): unknown => {
153  try {
154    return JSON.parse(text.replace(/^/, ''))
155  } catch {
156    return undefined
157  }
158}
159
160const slashed = (path: string): string => {
161  let out = path.split('\\').join('/')
162  while (out.length > 1 && out.endsWith('/')) {
163    out = out.slice(0, -1)
164  }
165
166  return out
167}
168
169// Output of `git rev-parse --path-format=absolute --git-common-dir --show-toplevel`:
170// the main checkout is the parent of the common `.git` dir; a bare repo falls back to the toplevel.
171export const repoRootFrom = (stdout: string): string | undefined => {
172  const [common, top] = stdout.split(/\r?\n/).map(line => line.trim())
173  if (common !== undefined && common !== '') {
174    const dir = slashed(common)
175    if (dir.endsWith('/.git')) {
176      return dir.slice(0, -'/.git'.length)
177    }
178  }
179
180  return top === undefined || top === '' ? undefined : slashed(top)
181}
182
183// The engine's `$` cannot cross an import, so the host passes the few operations this module needs
184// as closures: { home: async () => (await $.env.get('USERPROFILE')) ?? (await $.env.get('HOME')), exists: p => $.fs.exists(p), read: p => $.fs.read(p),
185// git: argv => $.process.run(argv, { timeoutMs: 10_000 }), now: () => $.clock.now() }.
186export type Host = {
187  home: () => Promise<string | undefined>
188  exists: (path: string) => Promise<boolean>
189  read: (path: string) => Promise<string>
190  git: (argv: string[]) => Promise<{ exitCode: number; stdout: string }>
191  now: () => Promise<number>
192}
193
194export const homeOf = async (host: Host): Promise<string | undefined> => {
195  let home: string | undefined
196  try {
197    home = await host.home()
198  } catch {
199    home = undefined
200  }
201
202  return home === undefined || home === '' ? undefined : slashed(home)
203}
204
205const readLayer = async (host: Host, path: string): Promise<unknown> => {
206  try {
207    if (!(await host.exists(path))) {
208      return undefined
209    }
210
211    return parseJson(await host.read(path))
212  } catch {
213    return undefined
214  }
215}
216
217export const repoRoot = async (host: Host): Promise<string | undefined> => {
218  try {
219    const git = await host.git(['git', 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel'])
220
221    return git.exitCode === 0 ? repoRootFrom(git.stdout) : undefined
222  } catch {
223    return undefined
224  }
225}
226
227// Whether the repo opted into orca-stack, with `.orca-stack.json` or `.orca-stack.local.json`: mods that inject text
228// into the session, or that gate on it, only do so in such a project.
229export const hasProjectConfig = async (host: Host): Promise<boolean> => {
230  const root = await repoRoot(host)
231  if (root === undefined) {
232    return false
233  }
234  for (const name of ['.orca-stack.json', '.orca-stack.local.json']) {
235    try {
236      if (await host.exists(`${root}/${name}`)) {
237        return true
238      }
239    } catch {
240      // An unreadable layer counts as missing.
241    }
242  }
243
244  return false
245}
246
247const loadFor = async (host: Host, home: string | undefined, root: string | undefined): Promise<StackConfig> =>
248  mergeConfig(
249    home === undefined ? undefined : await readLayer(host, `${home}/.orca-stack/config.json`),
250    root === undefined ? undefined : await readLayer(host, `${root}/.orca-stack.json`),
251    root === undefined ? undefined : await readLayer(host, `${root}/.orca-stack.local.json`),
252  )
253
254// Never throws: a missing or broken layer is skipped.
255export const loadConfig = async (host: Host): Promise<StackConfig> =>
256  loadFor(host, await homeOf(host), await repoRoot(host))
257
258// loadConfig with a short memory, for hooks that run on every tool call. The memory is keyed by the
259// resolved home and repo root, so switching to another checkout never serves the previous one's rules.
260let remembered: { key: string; at: number; config: StackConfig } | undefined
261
262export const currentConfig = async (host: Host, maxAgeMs = 30_000): Promise<StackConfig> => {
263  const home = await homeOf(host)
264  const root = await repoRoot(host)
265  const key = `${home ?? ''}|${root ?? ''}`
266  const now = await host.now()
267  if (remembered !== undefined && remembered.key === key && now - remembered.at < maxAgeMs) {
268    return remembered.config
269  }
270  const config = await loadFor(host, home, root)
271  remembered = { key, at: now, config }
272
273  return config
274}
275
276export const forgetConfig = (): void => {
277  remembered = undefined
278}
279

1export type Mensaje = { id: string; to: string; text: string; at: number }
2
3declare module 'claude-code' {
4  interface PluginState {
5    'bandeja-mensajes': { items: Mensaje[] }
6  }
7}
8