deps

1import type { Register } from 'claude-code'
2
3import { registerCommands } from './engine'
4import { answerCommandsWithRead } from './hosts/command-read'
5import { rule as deps } from './rules/deps'
6
7export const register: Register = on => {
8  const rules = [deps]
9  registerCommands(on, rules)
10  answerCommandsWithRead(on, [deps])
11}
12

1import { atom, update } from 'claude-code'
2import type { On, ProcessRunResult, SessionUsage, UiCopyResult } from 'claude-code'
3
4import type { CommandRecord } from '../types'
5import { draw } from './render'
6import { EMPTY, observe } from './tracker'
7
8// What the engine knows about the session beside the record. A figure the
9// host does not have is left out, never zeroed, so a rule can say "n/a".
10export type Facts = {
11  turns?: number
12  elapsedMs?: number
13  contextPercent?: number
14  costUsd?: number
15  // The engine's clock now (epoch ms), for a rule that needs the date.
16  nowMs?: number
17}
18
19// What a rule may reach beyond the record, as closures over the host calls
20// (a rule never holds `$`). A rule that needs none of it ignores the argument.
21export type CommandTools = {
22  // The session's working directory.
23  cwd: () => Promise<string>
24  // `git -C <cwd> <args>`: stdout, or undefined when git exits non-zero (which
25  // is also what a directory outside any repo answers). Output past the host's
26  // 4 MiB cap, or a git that times out, throws.
27  git: (...args: string[]) => Promise<string | undefined>
28  exists: (path: string) => Promise<boolean>
29  // The text of a file (a relative path is under the cwd), or undefined when it
30  // is missing, unreadable or over the host's 4 MiB cap.
31  read: (path: string) => Promise<string | undefined>
32  // Creates the file and its directories.
33  write: (path: string, text: string) => Promise<void>
34  // `git -C <cwd> <args>` with the exit code kept, for a command that must tell
35  // "no match" (1) from a real failure. Never throws.
36  gitRun: (...args: string[]) => Promise<Ran>
37  // Any program, killed after `timeoutMs`. Never throws: a program that is not
38  // installed answers a non-zero code.
39  run: (argv: readonly string[], timeoutMs: number) => Promise<Ran>
40  // The entries of a directory, or undefined when it is missing or unreadable.
41  list: (path: string) => Promise<{ name: string; isDir: boolean }[] | undefined>
42}
43
44// What a program answered. `timedOut` and `truncated` (output past the 4 MiB
45// cap) are set when stdout cannot be trusted as complete.
46export type Ran = { code: number; stdout: string; stderr: string; timedOut: boolean; truncated: boolean }
47
48// What a rule answers: text to print and copy, or `{ text, copy: false }` for
49// a message that is not a result (an error must not replace the clipboard).
50export type Composed = string | { text: string; copy: false }
51
52// One slash command: its name and description, and how it turns the session
53// record into the text it prints. Pure unless it uses `tools`.
54export type CommandRule = {
55  name: string
56  description: string
57  // `args` is what the person typed after the command name, trimmed.
58  compose: (record: CommandRecord, facts: Facts, tools: CommandTools, args: string) => Composed | Promise<Composed>
59}
60
61export const GIT_TIMEOUT_MS = 15_000
62
63// A state value is written only by the plugin that owns it, and the owner is
64// the mod's name. The host wants the owner as a literal, so this source writes
65// the first mod's name and scripts/build.mjs swaps in each mod's own name
66// (engine.json, stateOwner). The same swap runs in types/index.d.ts.
67const record = atom({ plugin: 'deps', key: 'record' } as const, EMPTY)
68
69export const attempt = async <T>(read: () => Promise<T>): Promise<T | undefined> => {
70  try {
71    return await read()
72  } catch {
73    return undefined
74  }
75}
76
77// Takes a closure that starts the program, never `$` itself. The host rejects both
78// for a program that cannot start and for one still running at the timeout, and
79// the message does not say which, so a rejection that took nearly the whole
80// timeout counts as a timeout.
81export const exec = async (start: () => Promise<ProcessRunResult>, timeoutMs: number, now: () => Promise<number>): Promise<Ran> => {
82  const began = await now()
83  try {
84    const ran = await start()
85    return { code: ran.exitCode, stdout: ran.stdout, stderr: ran.stderr, timedOut: false, truncated: ran.isStdoutTruncated }
86  } catch (error) {
87    const message = error instanceof Error ? error.message : String(error)
88    const slow = (await now()) - began >= timeoutMs * 0.9
89    return { code: -1, stdout: '', stderr: '', timedOut: slow || /time/i.test(message), truncated: false }
90  }
91}
92
93// The tools a host does not give. A rule that calls one fails with a message,
94// and its tests fail: name what it uses in engine.json `needs`.
95const absent = (name: string) => (): Promise<never> =>
96  Promise.reject(new Error(`${name} is not given to this mod; name it in engine.json needs`))
97
98export const NO_TOOLS: CommandTools = {
99  cwd: absent('cwd'),
100  git: absent('git'),
101  exists: absent('exists'),
102  read: absent('read'),
103  write: absent('write'),
104  gitRun: absent('gitRun'),
105  run: absent('run'),
106  list: absent('list'),
107}
108
109// What every command reads besides its tools, as closures over the hook's `$`.
110export type CommandReads = {
111  usage: () => Promise<SessionUsage>
112  turns: () => Promise<number>
113  now: () => Promise<number>
114  kept: () => Promise<CommandRecord>
115  // Absent for a host that never copies: the answer is then the text alone, and
116  // the mod does not hold the clipboard call at all.
117  copy?: (text: string) => Promise<UiCopyResult>
118}
119
120// Answers one slash command: the rule composes its text from the record, the
121// facts and its tools, and a result is copied to the clipboard.
122export const answerCommand = async (rule: CommandRule, args: string, tools: CommandTools, reads: CommandReads): Promise<{ text: string }> => {
123  const usage = await attempt(reads.usage)
124  const turns = await attempt(reads.turns)
125  const now = await attempt(reads.now)
126  const kept = await attempt(reads.kept)
127
128  const facts: Facts = {
129    ...(turns === undefined ? {} : { turns }),
130    ...(now === undefined ? {} : { nowMs: now }),
131    ...(usage === undefined || now === undefined ? {} : { elapsedMs: Math.max(0, now - usage.startedAt) }),
132    ...(usage?.context.percent === undefined ? {} : { contextPercent: usage.context.percent }),
133    ...(usage?.cost === undefined ? {} : { costUsd: usage.cost.usd }),
134  }
135
136  let composed: Composed
137  try {
138    composed = await rule.compose(kept ?? EMPTY, facts, tools, args.trim())
139  } catch (error) {
140    return { text: `${rule.name}: failed, ${error instanceof Error ? error.message : String(error)}` }
141  }
142
143  if (typeof composed !== 'string') return { text: composed.text }
144  const text = composed
145  const copier = reads.copy
146  if (copier === undefined) return { text }
147
148  const copy = await attempt(() => copier(text))
149  const note = copy === undefined ? 'not copied (clipboard error)' : copy.isCopied ? 'copied to clipboard' : `not copied (${copy.reason})`
150  return { text: `${text}\n\n${note}` }
151}
152
153// The hooks every mod of the engine has. Each command's own answer is a host
154// (engine.json hosts), so a command gets only the tools its rule uses.
155export const registerCommands = (on: On, rules: readonly CommandRule[]): void => {
156  // The one tracker every rule reads. It lives in `$.state`, so a hot reload
157  // of the mod keeps the session so far.
158  on('tool.call', async ($, e, next) => {
159    const ran = await next(e)
160    try {
161      await update($, record, so_far => observe(so_far, e, ran))
162    } catch (error) {
163      await $.ui.log(`command: could not record ${e.tool}, ${error instanceof Error ? error.message : String(error)}`)
164    }
165    return ran
166  })
167
168  // /clear ends the conversation without a new session.start: start over.
169  on('session.end', async ($, e, next) => {
170    if (e.reason === 'clear') await update($, record, () => EMPTY)
171    return next(e)
172  })
173
174  on('session.start', async ($, e, next) => {
175    for (const rule of rules) await $.command.register({ name: rule.name, description: rule.description })
176    return next(e)
177  })
178
179  // A surface without Box or Text keeps the plain output row.
180  for (const rule of rules) {
181    on('ui.render', { component: 'CommandOutput', props: { command: rule.name } }, ($, e, next) => {
182      const { Box, Text } = $.ui.resolve(e)
183      return Box === undefined || Text === undefined ? next(e) : draw({ Box, Text }, e.props.text)
184    })
185  }
186}
187

1import { atom, read } from 'claude-code'
2import type { On } from 'claude-code'
3
4import { answerCommand, GIT_TIMEOUT_MS, attempt, NO_TOOLS } from '../engine'
5import type { CommandRule, CommandTools } from '../engine'
6import { EMPTY } from '../tracker'
7
8// The session record the engine keeps; the build swaps in the mod's name.
9const record = atom({ plugin: 'deps', key: 'record' } as const, EMPTY)
10
11// The commands whose rules read the repo with git and read project files.
12export const answerCommandsWithRead = (on: On, rules: readonly CommandRule[]): void => {
13  for (const rule of rules) {
14    on('command.run', { command: rule.name }, async ($, event) => {
15      const tools: CommandTools = {
16        ...NO_TOOLS,
17        cwd: () => $.session.cwd(),
18        git: async (...args) => {
19          const dir = await $.session.cwd()
20          const ran = await $.process.run(['git', '-C', dir, ...args], { cwd: dir, timeoutMs: GIT_TIMEOUT_MS })
21          if (ran.isStdoutTruncated) throw new Error(`git ${args[0]} output passed the 4 MiB cap`)
22          return ran.exitCode === 0 ? ran.stdout : undefined
23        },
24        read: path => attempt(() => $.fs.read(path)),
25      }
26      return answerCommand(rule, event.args ?? '', tools, {
27        usage: () => $.session.usage(),
28        turns: () => $.session.turns(),
29        now: () => $.clock.now(),
30        kept: () => read($, record),
31        copy: text => $.ui.copy({ text }),
32      })
33    })
34  }
35}
36

1import type { CommandRule, CommandTools, Composed } from '../engine'
2import { finish, isRepo, message, notARepo, repoRoot } from '../helpers'
3import { cargoDeps, goDeps, npmDeps, pyprojectDeps, requirementsDeps, type Dep } from '../manifests'
4
5const MAX_ROWS = 100
6
7type Source = { file: string; parse: (text: string) => Dep[] | undefined }
8
9// The order the groups print in.
10const SOURCES: readonly Source[] = [
11  { file: 'package.json', parse: npmDeps },
12  { file: 'pyproject.toml', parse: pyprojectDeps },
13  { file: 'requirements.txt', parse: requirementsDeps },
14  { file: 'go.mod', parse: goDeps },
15  { file: 'Cargo.toml', parse: cargoDeps },
16]
17
18const row = (d: Dep): string => `  ${d.name}  ${d.version}${d.kind === undefined ? '' : `  (${d.kind})`}`
19
20// A group is its header and rows. The rows are what the cap counts.
21type Group = { header: string; rows: string[] }
22
23const group = (file: string, deps: readonly Dep[] | undefined): Group =>
24  deps === undefined
25    ? { header: file, rows: ['  could not be parsed'] }
26    : { header: `${file} (${deps.length})`, rows: deps.length === 0 ? ['  none'] : deps.map(row) }
27
28// Keeps the first MAX_ROWS rows across all groups, then one "+N more" line.
29// Groups are set apart by a blank line.
30const limited = (groups: readonly Group[]): string[] => {
31  const total = groups.reduce((sum, g) => sum + g.rows.length, 0)
32  let budget = MAX_ROWS
33  const shown = groups.flatMap(g => {
34    if (budget <= 0) return []
35    const rows = g.rows.slice(0, budget)
36    budget -= rows.length
37    return [['', g.header, ...rows]]
38  })
39  return [...shown.flat(), ...(total > MAX_ROWS ? ['', `+${total - MAX_ROWS} more`] : [])]
40}
41
42const compose = async (_record: unknown, _facts: unknown, tools: CommandTools): Promise<Composed> => {
43  if (!(await isRepo(tools))) return notARepo(await tools.cwd())
44  const root = (await repoRoot(tools)) ?? (await tools.cwd())
45  const found: Group[] = []
46  for (const { file, parse } of SOURCES) {
47    const text = await tools.read(`${root}/${file}`)
48    if (text !== undefined) found.push(group(file, parse(text)))
49  }
50  if (found.length === 0) return message('No package.json, pyproject.toml, requirements.txt, go.mod or Cargo.toml at the repo root.')
51  return finish(['Direct dependencies', ...limited(found)].join('\n'))
52}
53
54export const rule: CommandRule = {
55  name: 'deps',
56  description: 'List direct dependencies with versions from package.json, pyproject.toml, requirements.txt, go.mod and Cargo.toml, and copy it',
57  compose,
58}
59

1import type { RenderElement } from 'claude-code'
2
3type Tag = Parameters<typeof h>[0]
4export type Parts = { Box: Tag; Text: Tag }
5
6// Draws a command's output row as a bordered box, one Text per line so the
7// monospace layout holds on every surface. The engine ends each answer with
8// a blank line and a one-line note; the note sits outside the box.
9export const draw = ({ Box, Text }: Parts, full: string): RenderElement => {
10  const split = full.lastIndexOf('\n\n')
11  const body = split < 0 ? full : full.slice(0, split)
12  const note = split < 0 ? '' : full.slice(split + 2)
13
14  // h answers a node; two Boxes around Texts always make an element.
15  return h(
16    Box,
17    { flexDirection: 'column' },
18    h(
19      Box,
20      { flexDirection: 'column', borderStyle: 'round', paddingX: 1, alignSelf: 'flex-start' },
21      ...body.split('\n').map(line => h(Text, null, line === '' ? ' ' : line)),
22    ),
23    note === '' ? null : h(Text, { dimColor: true }, note),
24  ) as RenderElement
25}
26

1import type { ToolCallResult } from 'claude-code'
2
3import type { CommandRecord } from '../types'
4import { redact } from './patterns'
5
6export const EMPTY: CommandRecord = { calls: 0, tools: {}, files: [], commands: [], commandsRun: 0, blocked: 0, errored: 0 }
7
8const MAX_COMMANDS = 200
9const MAX_COMMAND_LENGTH = 200
10const FILE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit'])
11
12type Call = { readonly tool: string; readonly [argument: string]: unknown }
13type Answer = Pick<ToolCallResult, 'deny' | 'isError'> | { readonly deny?: undefined; readonly isError?: boolean }
14
15const text = (value: unknown): string | undefined => (typeof value === 'string' ? value : undefined)
16
17const touchedFile = (e: Call): string | undefined =>
18  FILE_TOOLS.has(e.tool) ? (text(e.file_path) ?? text(e.notebook_path)) : undefined
19
20// Redacts before cutting, so a credential is never kept half-cut.
21const keep = (raw: string, limit: number): string => redact(raw).slice(0, limit)
22
23// The record after one more tool call. Pure: the record it is given is not
24// changed. A denied call counts as a call and as blocked, but it touched no
25// file and ran no command.
26export const observe = (record: CommandRecord, e: Call, ran: Answer): CommandRecord => {
27  const isDenied = ran.deny !== undefined
28  const file = isDenied ? undefined : touchedFile(e)
29  const command = isDenied || e.tool !== 'Bash' ? undefined : text(e.command)
30  const kept = file === undefined ? undefined : keep(file, 500)
31
32  return {
33    calls: record.calls + 1,
34    tools: { ...record.tools, [e.tool]: (record.tools[e.tool] ?? 0) + 1 },
35    files: kept === undefined || record.files.includes(kept) ? record.files : [...record.files, kept],
36    commands: command === undefined ? record.commands : [...record.commands, keep(command, MAX_COMMAND_LENGTH)].slice(-MAX_COMMANDS),
37    commandsRun: record.commandsRun + (command === undefined ? 0 : 1),
38    blocked: record.blocked + (isDenied ? 1 : 0),
39    errored: record.errored + (!isDenied && ran.isError === true ? 1 : 0),
40  }
41}
42

1import type { Composed, CommandTools } from './engine'
2import { redact } from './patterns'
3
4export const lines = (text: string | undefined): string[] =>
5  (text ?? '').split('\n').filter(line => line.length > 0)
6
7// True inside a git work tree.
8export const isRepo = async (tools: CommandTools): Promise<boolean> =>
9  (await tools.git('rev-parse', '--is-inside-work-tree')) !== undefined
10
11// An answer that is a message, not a result: printed, never copied.
12export const message = (text: string): Composed => ({ text, copy: false })
13
14export const notARepo = (dir: string): Composed =>
15  message(`Not a git repository: ${dir}\nRun this command from a folder inside a git repo.`)
16
17// Everything a command prints or writes passes here last: commit subjects and
18// paths are free text and can carry a credential.
19export const finish = (text: string): string => redact(text)
20
21// "1 tool call", "2 tool calls".
22export const count = (n: number, noun: string): string => `${n} ${noun}${n === 1 ? '' : 's'}`
23
24// Bullets for the first `limit` items, then one line for the rest.
25export const bullets = (items: readonly string[], limit: number, indent = ''): string[] => [
26  ...items.slice(0, limit).map(item => `${indent}- ${item}`),
27  ...(items.length > limit ? [`${indent}- and ${items.length - limit} more`] : []),
28]
29
30// Items grouped by key, in first-seen order (Map.groupBy is past the es2023 lib).
31export const groupBy = <T>(items: readonly T[], key: (item: T) => string): [string, T[]][] => {
32  // Built in place: copying per item would be quadratic on a long git log.
33  const groups = new Map<string, T[]>()
34  for (const item of items) {
35    const mine = groups.get(key(item))
36    if (mine === undefined) groups.set(key(item), [item])
37    else mine.push(item)
38  }
39  return [...groups]
40}
41
42// The repo's top folder (not the cwd), or undefined outside a repo.
43export const repoRoot = async (tools: CommandTools): Promise<string | undefined> =>
44  (await tools.git('rev-parse', '--show-toplevel'))?.trim() || undefined
45
46// The first `limit` rows, then "+N more" for the rest (the todos wording).
47export const cap = (rows: readonly string[], limit: number): string[] => [
48  ...rows.slice(0, limit),
49  ...(rows.length > limit ? [`+${rows.length - limit} more`] : []),
50]
51

1import { pairs, sections, stringArray, versionOf } from './toml'
2
3// One direct dependency. `kind` is set for anything but a plain runtime one.
4export type Dep = { name: string; version: string; kind?: string }
5
6const dep = (name: string, version: string, kind?: string): Dep => ({ name, version, ...(kind === undefined ? {} : { kind }) })
7
8const NPM_KINDS: readonly [string, string | undefined][] = [
9  ['dependencies', undefined],
10  ['devDependencies', 'dev'],
11  ['peerDependencies', 'peer'],
12  ['optionalDependencies', 'optional'],
13]
14
15// Undefined when the text is not JSON (the message is not echoed: a parse error repeats the input).
16export const npmDeps = (text: string): Dep[] | undefined => {
17  let data: unknown
18  try {
19    data = JSON.parse(text)
20  } catch {
21    return undefined
22  }
23  if (typeof data !== 'object' || data === null) return undefined
24  const table = data as Record<string, unknown>
25  return NPM_KINDS.flatMap(([field, kind]) => {
26    const found = table[field]
27    if (typeof found !== 'object' || found === null) return []
28    return Object.entries(found).map(([name, version]) => dep(name, typeof version === 'string' ? version : '*', kind))
29  })
30}
31
32// "requests>=2.31 ; python_version < '3.11'" and "pydantic[email]>=2,<3" are
33// a name and the version spec; the extras and the marker are left out.
34const REQUIREMENT = /^([A-Za-z0-9][A-Za-z0-9._-]*)\s*(?:\[[^\]]*\])?\s*([<>=!~][^;]*?)?\s*(?:;.*)?$/
35
36const requirement = (spec: string, kind?: string): Dep | undefined => {
37  const hit = REQUIREMENT.exec(spec.trim())
38  return hit === null ? undefined : dep(hit[1] ?? spec, (hit[2] ?? '').replace(/\s+/g, '') || '*', kind)
39}
40
41const present = (found: (Dep | undefined)[]): Dep[] => found.filter((d): d is Dep => d !== undefined)
42
43export const pyprojectDeps = (text: string): Dep[] => {
44  const all = sections(text)
45  const poetry = (name: string, kind?: string): Dep[] =>
46    pairs(all.get(name) ?? []).filter(([key]) => key !== 'python').map(([key, value]) => dep(key, versionOf(value), kind))
47  return [
48    ...present((stringArray(all.get('project') ?? [], 'dependencies') ?? []).map(spec => requirement(spec))),
49    ...pairs(all.get('project.optional-dependencies') ?? []).flatMap(([group]) =>
50      present((stringArray(all.get('project.optional-dependencies') ?? [], group) ?? []).map(spec => requirement(spec, 'optional'))),
51    ),
52    ...poetry('tool.poetry.dependencies'),
53    ...poetry('tool.poetry.dev-dependencies', 'dev'),
54    ...[...all.keys()]
55      .filter(name => /^tool\.poetry\.group\.[^.]+\.dependencies$/.test(name))
56      .flatMap(name => poetry(name, 'dev')),
57  ]
58}
59
60// Lines that set an option or pull in another file are not requirements.
61export const requirementsDeps = (text: string): Dep[] =>
62  text.split('\n').flatMap(row => {
63    const line = row.replace(/\s#.*$/, '').trim()
64    if (line === '' || line.startsWith('#') || line.startsWith('-')) return []
65    return [requirement(line) ?? dep(line, '*')]
66  })
67
68export const goDeps = (text: string): Dep[] => {
69  let inBlock = false
70  const found: Dep[] = []
71  for (const row of text.split('\n')) {
72    const line = row.trim()
73    if (inBlock && line === ')') inBlock = false
74    else if (/^require\s*\($/.test(line)) inBlock = true
75    else if (!line.startsWith('//')) {
76      const hit = (inBlock ? /^(\S+)\s+(\S+)(.*)$/ : /^require\s+(\S+)\s+(\S+)(.*)$/).exec(line)
77      if (hit !== null && !/\/\/\s*indirect/.test(hit[3] ?? '')) found.push(dep(hit[1] ?? '', hit[2] ?? '*'))
78    }
79  }
80  return found
81}
82
83const CARGO_KINDS: readonly [string, string | undefined][] = [
84  ['dependencies', undefined],
85  ['dev-dependencies', 'dev'],
86  ['build-dependencies', 'build'],
87]
88
89export const cargoDeps = (text: string): Dep[] => {
90  const all = sections(text)
91  return CARGO_KINDS.flatMap(([table, kind]) => [
92    ...pairs(all.get(table) ?? []).map(([name, value]) => dep(name, versionOf(value), kind)),
93    // [dependencies.tokio] with its own rows.
94    ...[...all]
95      .filter(([name]) => name.startsWith(`${table}.`))
96      .map(([name, body]) => dep(name.slice(table.length + 1), pairs(body).find(([key]) => key === 'version')?.[1].replace(/^["']|["']$/g, '') ?? '*', kind)),
97  ])
98}
99

1// Shared secret shapes, ported from claude-secret-guard-kit
2// (hooks/secret-patterns.sh). Every guard rule reads them from here so the
3// shapes stay in sync.
4
5// Shapes of live credential VALUES. Spliced where the source text would
6// otherwise match the shape it defines.
7const SECRET_VALUE_SOURCES = [
8  'AKIA[0-9A-Z]{16}',
9  '-----BEGIN [A-Z ]*PRIVATE KEY-----',
10  'gh[pousr]_[A-Za-z0-9]{30,}',
11  'github_pat_[A-Za-z0-9_]{30,}',
12  'sk-ant-[A-Za-z0-9_-]{20,}',
13  'sk-(proj-)?[A-Za-z0-9_-]{32,}',
14  'AIza[0-9A-Za-z_-]{30,}',
15  'xox[baprs]-[A-Za-z0-9-]{10,}',
16  'hooks\\.slack\\.com/services/T[A-Za-z0-9]+/B[A-Za-z0-9]+/[A-Za-z0-9]+',
17  '[sr]k_live_[0-9a-zA-Z]{20,}',
18  'eyJ[A-Za-z0-9_-]{10,}\\.eyJ[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}',
19  '(postgres(ql)?|mysql|mongodb(\\+srv)?|redis|amqp|mssql)://[^:/@\\s]+:[^@\\s]+@',
20  // Any other URL with a user and a password, such as git+https://user:token@host.
21  '[a-z][a-z0-9+.-]*://[^:/@\\s]+:[^/@\\s]+@',
22  'npm_[A-Za-z0-9]{36}',
23  'SG\\.[A-Za-z0-9_-]{22}\\.[A-Za-z0-9_-]{43}',
24  'SK[0-9a-fA-F]{32}',
25  'service_' + 'account.{0,120}private_' + 'key_id',
26  'AccountKey=[A-Za-z0-9+/=]{60,}',
27  'hf_[A-Za-z0-9]{30,}',
28]
29
30export const SECRET_VALUE = new RegExp(SECRET_VALUE_SOURCES.join('|'))
31
32// The same shapes for `git grep -E` (POSIX ERE has no \s, so the class is spelled out).
33export const SECRET_VALUE_ERE = SECRET_VALUE_SOURCES.join('|').replaceAll('\\s', '[:space:]')
34
35export const SECRET_VALUE_GLOBAL = new RegExp(SECRET_VALUE_SOURCES.join('|'), 'g')
36
37// Secret-looking FILE names. Whole-ish tokens to keep false positives low.
38export const SECRET_NAME =
39  /\.env(\.[A-Za-z0-9_-]+)?|\.pem|\.key|\.p12|\.pfx|\.keystore|\.jks|id_rsa|id_dsa|id_ecdsa|id_ed25519|secrets?\.(json|ya?ml|txt)|credentials|\.pgpass|\.htpasswd|\.npmrc|\.netrc|serviceaccount.*\.json|\.p8/i
40
41// Public env templates that must never trigger a prompt.
42export const SECRET_NAME_SAFE = /\.env\.(example|sample|template|dist|md)/g
43
44// Variable names whose values are secrets.
45export const SECRET_VAR_NAMES = '(KEY|SECRET|TOKEN|PASSWORD|PASSWD|PASS|CREDENTIAL|PRIVATE)'
46
47export const redact = (text: string): string => text.replace(SECRET_VALUE_GLOBAL, '[REDACTED]')
48
49// A path or command that names a secret-looking file, public templates aside.
50export const isSecretName = (text: string): boolean => SECRET_NAME.test(text.replace(SECRET_NAME_SAFE, ''))
51

1// The little of TOML that dependency and script tables use: sections, plain
2// `key = value` rows and string arrays. Not a TOML parser.
3
4// Drops a trailing "# comment", leaving a "#" inside quotes alone.
5const stripComment = (line: string): string => {
6  let quote = ''
7  for (let i = 0; i < line.length; i += 1) {
8    const ch = line[i]
9    if (quote !== '') quote = ch === quote ? '' : quote
10    else if (ch === '"' || ch === "'") quote = ch
11    else if (ch === '#') return line.slice(0, i)
12  }
13  return line
14}
15
16// Body rows (comments dropped) by section name, "" for rows before any header.
17// An array-of-tables header ([[bin]]) starts a section nobody asks for.
18export const sections = (text: string): Map<string, string[]> => {
19  const found = new Map<string, string[]>()
20  let current = ''
21  for (const raw of text.split('\n')) {
22    const row = stripComment(raw).trimEnd()
23    const header = /^\s*\[([^\[\]]+)\]\s*$/.exec(row)
24    if (header !== null) current = (header[1] ?? '').trim()
25    else if (/^\s*\[\[/.test(row)) current = `[[${row.trim()}`
26    else if (row.trim() !== '') found.set(current, [...(found.get(current) ?? []), row])
27  }
28  return found
29}
30
31const STRING = /"((?:[^"\\]|\\.)*)"|'([^']*)'/g
32
33// `key = [ "a", "b" ]` across any number of rows. Undefined when absent.
34export const stringArray = (body: readonly string[], key: string): string[] | undefined => {
35  const text = body.join('\n')
36  const start = new RegExp(`^\\s*${key}\\s*=\\s*\\[`, 'm').exec(text)
37  if (start === null) return undefined
38  let quote = ''
39  let end = text.length
40  for (let i = start.index + start[0].length; i < text.length; i += 1) {
41    const ch = text[i]
42    if (quote !== '') quote = ch === quote ? '' : quote
43    else if (ch === '"' || ch === "'") quote = ch
44    else if (ch === ']') {
45      end = i
46      break
47    }
48  }
49  const inside = text.slice(start.index + start[0].length, end)
50  return [...inside.matchAll(STRING)].map(hit => hit[1] ?? hit[2] ?? '')
51}
52
53// One-row `name = value` pairs. A value that goes on over several rows keeps its first row.
54export const pairs = (body: readonly string[]): [string, string][] =>
55  body.flatMap(row => {
56    const hit = /^\s*("[^"]+"|[A-Za-z0-9_.-]+)\s*=\s*(.*?)\s*$/.exec(row)
57    return hit === null ? [] : [[(hit[1] ?? '').replace(/^"|"$/g, ''), hit[2] ?? '']]
58  })
59
60const unquote = (raw: string): string => raw.replace(/^["']|["']$/g, '')
61
62// The version a dependency value stands for: a string is the version; an inline
63// table gives its `version`, else what it points at ("path", "git", "workspace").
64export const versionOf = (raw: string): string => {
65  if (/^["']/.test(raw)) return unquote(raw)
66  const version = /\bversion\s*=\s*["']([^"']*)["']/.exec(raw)
67  if (version !== null) return version[1] ?? '*'
68  for (const kind of ['workspace', 'path', 'git']) if (new RegExp(`\\b${kind}\\s*=`).test(raw)) return `(${kind})`
69  return '*'
70}
71

1// What the command engine keeps in `$.state`, so a hot reload does not lose
2// the session so far. Everything here is already redacted.
3export type CommandRecord = {
4  /** Every tool call seen, denied and errored ones included. */
5  calls: number
6  /** Calls per tool name. */
7  tools: Record<string, number>
8  /** Unique paths a Write, Edit, MultiEdit or NotebookEdit call touched. */
9  files: string[]
10  /** Every Bash command that ran (not denied), uncapped. */
11  commandsRun: number
12  /** The latest of those commands, newest last, capped. */
13  commands: string[]
14  /** Calls a hook denied. */
15  blocked: number
16  /** Calls that ran and came back as an error. */
17  errored: number
18}
19
20declare module 'claude-code' {
21  interface PluginState {
22    deps: { record: CommandRecord }
23  }
24}
25