@cmodjs/core 0.1.8 → 0.1.10

package/src/runtime/hooks.ts

@@ -1,15 +1,15 @@
-import type { Args, ClassicHookInputs, Frozen } from 'claude-code'
-import type { HookAnswer, ModEvent, ModHook } from '../mod.js'
+import type { Args, ClassicHookInputs, EventResult, Frozen } from 'claude-code'
+import type { HookAnswer, HookInput, ModEvent, ModHook } from '../mod.js'
 import { configFolders } from '../records.js'
 import type { Claude } from './claude.js'
 import type { RoutedHook } from './router.js'
-import { toolInputOf, type ToolCalls } from './tool-calls.js'
+import { reservedKeys, toolInputOf, type ToolCalls } from './tool-calls.js'
 import { callEffects, type FileAccess, type ToolUse } from '../utils/call-effects.js'
 import { dynamicPattern } from '../utils/parse-shell.js'
 import { messageOf } from '../utils/text.js'
 
 export type RoutedEvent =
-  | `classic.${ModEvent}`
+  | `classic.${Exclude<ModEvent, 'PreToolUse'>}`
   | 'tool.check'
   | 'tool.call'
   | 'prompt.submit'
@@ -19,16 +19,15 @@ export type RoutedEvent =
   | 'skill.prompt'
   | 'ui.render'
   | 'ui.press'
+  | 'ui.scroll'
   | 'ui.close'
   | 'cmod.call'
 
-export const permissionEvents: readonly RoutedEvent[] = ['tool.check', 'classic.PreToolUse', 'classic.PermissionRequest']
+export const permissionEvents: readonly RoutedEvent[] = ['tool.check', 'classic.PermissionRequest']
 
 type ClassicFields = Record<string, unknown>
 
-type PreToolUseInput = Parameters<ModHook<'PreToolUse'>>[0]
-
-type CallFiles = PreToolUseInput['files']
+type CallFiles = HookInput<'PreToolUse'>['files']
 
 const flags: readonly string[] = ['suppressOriginalPrompt', 'reloadSkills', 'retry']
 
@@ -50,18 +49,18 @@ const readFields: Record<ModEvent, readonly string[]> = {
   Stop: ['additionalContext'],
   StopFailure: [],
   CwdChanged: [],
+  FileChanged: [],
 }
 
-export function classicHook<E extends ModEvent>(name: string, event: E, hook: ModHook<E>, claude: Claude, calls: ToolCalls): RoutedHook<RoutedEvent> {
+export function classicHook<E extends Exclude<ModEvent, 'PreToolUse'>>(name: string, event: E, hook: ModHook<E>, claude: Claude, calls: ToolCalls): RoutedHook<RoutedEvent> {
   const inputOf = async (e: unknown): Promise<unknown> => {
-    if (event === 'PreToolUse') return preToolUseInput(name, e as Frozen<Args<'classic.PreToolUse'>>, claude, calls.agentOf)
     if (event !== 'PostToolUse' && event !== 'PostToolUseFailure') return e
     const input = e as ClassicHookInputs['PostToolUse' | 'PostToolUseFailure']
     const cwd = calls.cwdOf(input.tool_use_id) ?? input.cwd
     return { ...input, files: await callFiles(name, claude, { tool: input.tool_name, input: input.tool_input }, cwd) }
   }
   const resultOf = async (e: unknown): Promise<ClassicFields | undefined> => {
-    const answer = await hook((await inputOf(e)) as Parameters<ModHook<E>>[0])
+    const answer = await hook((await inputOf(e)) as HookInput<E>)
     if (answer === undefined) return undefined
     if (answer.systemMessage !== undefined) claude.ui.log(answer.systemMessage)
     return classicResult(event, answer)
@@ -69,17 +68,65 @@ export function classicHook<E extends ModEvent>(name: string, event: E, hook: Mo
   const routed = async (e: unknown, next: (e: unknown) => Promise<unknown>) => {
     const ours = await resultOf(e).catch((error: unknown): ClassicFields | undefined => {
       const reason = `${name}: the ${event} hook failed: ${messageOf(error)}`
-      if (event === 'PreToolUse') return { deny: reason }
       if (event === 'PermissionRequest') return { decision: { behavior: 'deny', message: reason } }
       claude.ui.log(reason)
       return undefined
     })
     if (ours === undefined) return next(e)
-    return mergeClassic(event, (await next(e)) as ClassicFields, ours)
+    return mergeClassic((await next(e)) as ClassicFields, ours)
   }
   return routed as unknown as RoutedHook<RoutedEvent>
 }
 
+type HeldDecision = { readonly decision: 'allow' | 'ask'; readonly reason?: string }
+
+export type HeldDecisions = Map<string, HeldDecision>
+
+export function preToolUseHook(name: string, hook: ModHook<'PreToolUse'>, claude: Claude, calls: ToolCalls, held: HeldDecisions | undefined): RoutedHook<'tool.call'> {
+  return async (e, next) => {
+    let ours: ClassicFields
+    try {
+      const answer = await hook(await preToolUseInput(name, e, claude, calls.agentOf))
+      if (answer?.systemMessage !== undefined) claude.ui.log(answer.systemMessage)
+      ours = answer === undefined ? {} : classicResult('PreToolUse', answer)
+    } catch (error) {
+      return { deny: `${name}: the PreToolUse hook failed: ${messageOf(error)}` }
+    }
+    if (typeof ours['deny'] === 'string') return { deny: ours['deny'] }
+    const decided = heldDecisionOf(ours)
+    if (decided !== undefined && held === undefined) {
+      return { deny: `${name}: the PreToolUse hook answered permissionDecision "${decided.decision}", so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod.` }
+    }
+    const updated = ours['updatedInput'] as Record<string, unknown> | undefined
+    const reserved = Object.fromEntries(Object.entries(e).filter(([key]) => reservedKeys.includes(key)))
+    const earlier = held?.get(e.tool_use_id)
+    if (decided !== undefined) held?.set(e.tool_use_id, earlier !== undefined && strictness.indexOf(earlier.decision) >= strictness.indexOf(decided.decision) ? earlier : decided)
+    let result: EventResult<'tool.call'>
+    try {
+      result = await next(updated === undefined ? e : ({ ...reserved, ...updated } as Frozen<Args<'tool.call'>>))
+    } finally {
+      if (decided !== undefined) held?.delete(e.tool_use_id)
+    }
+    const context = ours['additionalContext'] as string[] | undefined
+    if (context === undefined || result.deny !== undefined) return result
+    return { ...result, context: [...(result.context ?? []), ...context] }
+  }
+}
+
+export function heldDecisionHook(held: HeldDecisions): RoutedHook<'tool.check'> {
+  return async (e, next) => {
+    const below = await next(e)
+    const ours = e.tool_use_id === undefined ? undefined : held.get(e.tool_use_id)
+    return ours === undefined || below.decision === 'deny' ? below : ours
+  }
+}
+
+function heldDecisionOf(ours: ClassicFields): HeldDecision | undefined {
+  if (ours['allow'] !== undefined) return { decision: 'allow' }
+  if (typeof ours['ask'] !== 'string') return undefined
+  return ours['ask'] === '' ? { decision: 'ask' } : { decision: 'ask', reason: ours['ask'] }
+}
+
 const frontmatter = /^---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/
 
 const baseDirectoryLine = /^Base directory for this skill: [^\n]*\n\n/
@@ -101,7 +148,7 @@ export function userSkillHook(claude: Claude): RoutedHook<'skill.prompt'> {
   }
 }
 
-async function preToolUseInput(name: string, envelope: Frozen<Args<'classic.PreToolUse'>>, claude: Claude, agentOf: ToolCalls['agentOf']): Promise<PreToolUseInput> {
+async function preToolUseInput(name: string, envelope: Frozen<Args<'tool.call'>>, claude: Claude, agentOf: ToolCalls['agentOf']): Promise<HookInput<'PreToolUse'>> {
   const { tool, tool_use_id } = envelope
   const [session_id, cwd, { agentId, agentType }] = await Promise.all([claude.session.id(), claude.session.cwd(), agentOf(tool_use_id)])
   const tool_input = toolInputOf(envelope)
@@ -161,17 +208,9 @@ function classicResult(event: ModEvent, answer: HookAnswer): ClassicFields {
 
 export const strictness = ['allow', 'ask', 'deny'] as const
 
-function strictnessOf(result: ClassicFields): number {
-  return strictness.findLastIndex((decision) => result[decision] !== undefined)
-}
-
-function mergeClassic(event: ModEvent, below: ClassicFields, ours: ClassicFields): ClassicFields {
+function mergeClassic(below: ClassicFields, ours: ClassicFields): ClassicFields {
   const merged: ClassicFields = { ...below, ...ours }
   const context = [...((below['additionalContext'] as string[] | undefined) ?? []), ...((ours['additionalContext'] as string[] | undefined) ?? [])]
   if (context.length > 0) merged['additionalContext'] = context
-  if (event !== 'PreToolUse') return merged
-  const strictest = strictness[Math.max(strictnessOf(below), strictnessOf(ours))]
-  for (const decision of strictness) delete merged[decision]
-  if (strictest !== undefined) merged[strictest] = ours[strictest] ?? below[strictest]
   return merged
 }

package/src/runtime/lifecycle.ts

@@ -1,12 +1,12 @@
 import type { Args, EventResult, Frozen, HookBudget, HookStream, ProcessSpawnChunk, ProcessSpawnResult } from 'claude-code'
-import type { Mod, ModDefinition, ModEvent, ModHook } from '../mod.js'
+import type { HookInput, Mod, ModDefinition, ModEvent, ModHook } from '../mod.js'
 import { dataFolder, isAtLeast, parseEvent, readRecord, readSteps, scriptsSha256, storeFolder, type ReadFile, type RunnerEvent } from '../records.js'
 import { relativePath } from '../utils/paths.js'
 import { formatExit, listed, messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
 import { beforeDeadline } from './deadline.js'
 import { answerCall, dependencyCalls, notInstalled } from './dependencies.js'
-import { classicHook, permissionEvents, userSkillHook, type RoutedEvent } from './hooks.js'
+import { classicHook, heldDecisionHook, permissionEvents, preToolUseHook, userSkillHook, type HeldDecisions, type RoutedEvent } from './hooks.js'
 import { createRouter, type Router, type RouterNext } from './router.js'
 import { createState } from './state.js'
 import { toolCalls } from './tool-calls.js'
@@ -362,13 +362,15 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
   let staleCwd: string | undefined
   const area = createUi<State>({ name: definition.name, claude, router, progress, announce, mod: () => mod })
   const modState = createState<State>({ name: definition.name, initial: definition.state ?? {}, session, root, claude, changed: area.changed })
+  const held: HeldDecisions | undefined = runtime.checksPermissions() ? new Map() : undefined
   const mod: Mod<State> = {
     name: definition.name,
     state: modState.state,
     dataFolder: runtime.dataFolder,
     on(event, hook) {
       if (!hookEvents.includes(event)) hookEvents.push(event)
-      router.add(`classic.${event}`, classicHook(definition.name, event, hook, claude, agents))
+      if (event === 'PreToolUse') router.add('tool.call', preToolUseHook(definition.name, hook as ModHook<'PreToolUse'>, claude, agents, held))
+      else router.add(`classic.${event as Exclude<ModEvent, 'PreToolUse'>}`, classicHook(definition.name, event as Exclude<ModEvent, 'PreToolUse'>, hook as ModHook<Exclude<ModEvent, 'PreToolUse'>>, claude, agents))
     },
     use: (job) => job({ mod, claude, on: (event, hook) => router.add(event, hook), announce, reserveName, toolCalls: agents }),
     ui: area.ui,
@@ -380,9 +382,13 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
       read: (path) => claude.fs.read(path),
       write: (path, text) => claude.fs.write(path, text),
       list: (path) => claude.fs.list(path),
+      exists: (path) => claude.fs.exists(path),
+      stat: (path, options) => claude.fs.stat(path, options),
     },
     http: { fetch: (url, init) => claude.http.fetch(url, init) },
     settings: { read: (args) => claude.settings.read(args) },
+    session: { messages: claude.session.messages },
+    agent: { spawn: (args) => claude.agent.spawn(args) },
     get projectRoot() {
       return modState.root
     },
@@ -408,7 +414,7 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
       loadedCwd = nextCwd
       if (!hasMovedRoot) area.changed()
       if (nextCwd === oldCwd) return
-      const moved: Parameters<ModHook<'CwdChanged'>>[0] = { session_id: await claude.session.id(), cwd: nextCwd, hook_event_name: 'CwdChanged', old_cwd: oldCwd, new_cwd: nextCwd }
+      const moved: HookInput<'CwdChanged'> = { session_id: await claude.session.id(), cwd: nextCwd, hook_event_name: 'CwdChanged', old_cwd: oldCwd, new_cwd: nextCwd }
       await router.dispatch('classic.CwdChanged', moved as Frozen<Args<'classic.CwdChanged'>>, async () => ({}))
     } catch (error) {
       claude.ui.log(`${definition.name} keeps the state of ${modState.root} until the next prompt or folder move: ${messageOf(error)}`)
@@ -452,6 +458,7 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
   if (permissionHooks.length > 0 && !runtime.checksPermissions()) {
     throw new Error(`it decides permissions on ${listed(permissionHooks)}, so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod`)
   }
+  if (held !== undefined && hookEvents.includes('PreToolUse')) router.add('tool.check', heldDecisionHook(held))
   await failsAs('its open panes did not load', () => area.restorePanes())
   if (hookEvents.length > 0) added.push(`${hookEvents.length === 1 ? 'a hook' : 'hooks'} on ${listed(hookEvents)}`)
   return { mod, added }

package/src/runtime/ui.ts

@@ -1,5 +1,6 @@
 import type { ElementTable, MarkdownProps, PaneOpenArgs, RenderElement, Timer } from 'claude-code'
 import type { Mod, PaneHandle, ProgressStep } from '../mod.js'
+import { ProgressBar } from '../ui/components.js'
 import type { Pane } from '../ui/define-pane.js'
 import { Box, drawWith, Text } from '../ui/elements.js'
 import type { MarkdownKind, MarkdownReader } from '../ui/markdown.js'
@@ -109,23 +110,8 @@ function drawLine(line: Line, frame: number, columns: number | undefined): Rende
   const glyph = Text({ color: 'claude', children: spinner[frame % spinner.length] })
   if (line.step === undefined) return Text({ wrap: 'truncate-end', children: [glyph, ' ', title, Text({ dimColor: true, children: '…' })] })
   const { done, total, label = '' } = line.step
-  const count = `${done}/${total}`
-  const width = barWidth(columns, `${line.title}${count}${label}`.length)
-  const filled = total > 0 ? Math.round(Math.min(done / total, 1) * width) : 0
-  return Text({
-    wrap: 'truncate-end',
-    children: [
-      glyph,
-      ' ',
-      title,
-      '  ',
-      Text({ color: 'claude', children: '█'.repeat(filled) }),
-      Text({ color: 'subtle', children: '░'.repeat(width - filled) }),
-      '  ',
-      Text({ dimColor: true, children: count }),
-      ...(label === '' ? [] : ['  ', label]),
-    ],
-  })
+  const width = barWidth(columns, `${line.title}${done}/${total}${label}`.length)
+  return Text({ wrap: 'truncate-end', children: [glyph, ' ', title, '  ', ProgressBar({ done, total, width }), ...(label === '' ? [] : ['  ', label])] })
 }
 
 function barWidth(columns: number | undefined, textLength: number): number {
@@ -224,6 +210,7 @@ export type UiArea<State extends object> = {
 
 export function createUi<State extends object>({ name, claude, router, progress, announce, mod }: UiOptions<State>): UiArea<State> {
   const panes = new Map<string, Pane<State>>()
+  const paneLogs = new Map<string, (failure: string) => void>()
   const openPanes = new Set<string>()
   const requestedSizes = new Map<string, PaneSize>()
   const renders = new Set<string>()
@@ -291,9 +278,10 @@ export function createUi<State extends object>({ name, claude, router, progress,
     })
   }
 
-  const openAt = (pane: Pane<State>, size: PaneSize) => {
+  const openAt = (pane: Pane<State>, size: PaneSize, focus?: true) => {
     requestedSizes.set(pane.id, size)
-    return claude.ui.open({ id: pane.id, title: pane.title, ...size })
+    const { id, title, closeOnEscape, holdToasts } = pane
+    return claude.ui.open({ id, title, ...size, ...(closeOnEscape === true ? { closeOnEscape } : {}), ...(holdToasts === true ? { holdToasts } : {}), ...(focus === true ? { focus } : {}) })
   }
 
   const resize = async (pane: Pane<State>) => {
@@ -315,34 +303,58 @@ export function createUi<State extends object>({ name, claude, router, progress,
       if (pane === undefined || e.component !== 'Pane') return next(e)
       openPanes.add(pane.id)
       const table = claude.ui.resolve(e)
-      return drawWith(table, () => pane.render(mod(), e.props), markdownIn(table))
+      try {
+        return drawWith(table, () => pane.render(mod(), e.props), markdownIn(table))
+      } catch (error) {
+        paneLogs.get(pane.id)?.(`threw: ${messageOf(error)}`)
+        return drawWith(table, () => Text({ color: 'error', children: `The ${pane.title} pane could not draw: ${messageOf(error)}` }))
+      }
+    })
+    router.add('ui.scroll', async (e, next) => {
+      const pane = panes.get(e.requestId)
+      const moved = await next(e)
+      if (pane?.onScroll === undefined || e.component !== 'Pane' || moved.deny !== undefined) return moved
+      await handle(pane, 'onScroll', () => pane.onScroll?.(mod(), e))
+      return moved
     })
-    router.add('ui.close', (e, next) => {
+    router.add('ui.close', async (e, next) => {
       openPanes.delete(e.id)
-      return next(e)
+      const closed = await next(e)
+      const pane = panes.get(e.id)
+      if (pane?.onClose !== undefined) await handle(pane, 'onClose', () => pane.onClose?.(mod(), e))
+      return closed
     })
   }
 
+  const handle = async (pane: Pane<State>, handler: string, run: () => unknown) => {
+    try {
+      await run()
+    } catch (error) {
+      claude.ui.log(`${name}: the ${pane.title} pane's ${handler} threw: ${messageOf(error)}`)
+    }
+  }
+
   return {
     ui: {
       pane(pane) {
         if (panes.has(pane.id)) throw new Error(`${name}: the pane "${pane.id}" is already added. Give each pane its own id.`)
         panes.set(pane.id, pane)
+        paneLogs.set(pane.id, logOnce(`${pane.title} pane`))
         announce(`the ${pane.title} pane`)
         route()
         const handle: PaneHandle = {
           get isOpen() {
             return openPanes.has(pane.id)
           },
-          async open() {
-            const { isPlaced } = await openAt(pane, paneSize(pane, mod().state))
+          async open(options) {
+            const { isPlaced } = await openAt(pane, paneSize(pane, mod().state), options?.focus)
             if (isPlaced) openPanes.add(pane.id)
           },
           async close() {
             await claude.ui.close({ id: pane.id })
             openPanes.delete(pane.id)
           },
-          toggle: () => (openPanes.has(pane.id) ? handle.close() : handle.open()),
+          toggle: (options) => (openPanes.has(pane.id) ? handle.close() : handle.open(options)),
         }
         return handle
       },
@@ -376,7 +388,7 @@ export function createUi<State extends object>({ name, claude, router, progress,
           return drawWith(table, () => drawPieces([drawn], e.props.isFirstOfReply ? 'opensReply' : 'inReply'))
         })
       },
-      toast: (text) => claude.ui.toast(text),
+      toast: (text, options) => claude.ui.toast(text, options),
       async progress(title, task) {
         const line = progress.start(title)
         try {
@@ -386,6 +398,7 @@ export function createUi<State extends object>({ name, claude, router, progress,
         }
       },
       ask: (question, options) => claude.ui.ask(question, options),
+      scroll: (args) => claude.ui.scroll(args),
     },
     changed() {
       if (panes.size === 0 && renders.size === 0) return

package/src/shell.ts

@@ -0,0 +1 @@
+export { parseShell, type ParsedShell, type ShellCommand } from './utils/parse-shell.js'

package/src/testing/fake-claude.ts

@@ -12,8 +12,9 @@ export type Fakes = {
   fs: { read?: Claude['fs']['read']; write?: Claude['fs']['write']; list?: Claude['fs']['list']; exists?: Claude['fs']['exists']; stat?: Claude['fs']['stat'] }
   http: { fetch?: Claude['http']['fetch'] }
   settings: { read?: Claude['settings']['read'] }
-  ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open'] }
-  agent: { list?: Claude['agent']['list'] }
+  ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open']; scroll?: Claude['ui']['scroll'] }
+  session: { messages?: Claude['session']['messages'] }
+  agent: { list?: Claude['agent']['list']; spawn?: Claude['agent']['spawn'] }
   clock: { after?: Claude['clock']['after']; every?: Claude['clock']['every'] }
   cmod: { call?: Claude['cmod']['call'] }
 }
@@ -39,9 +40,10 @@ export type FakeClaude = {
 
 export function fakeClaude(plugin: { readonly name: string; readonly root: string }): FakeClaude {
   const calls: TestCall[] = []
-  const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, ui: {}, agent: {}, clock: {}, cmod: {} }
+  const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, ui: {}, session: {}, agent: {}, clock: {}, cmod: {} }
   const shown: Shown = { toasts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [] }
   const unplacedPanes = new Set<string>()
+  let focusedPane: string | undefined
   const store = new Map<string, unknown>()
 
   const faked = <Args extends readonly unknown[], Result>(call: string, answer: () => ((...args: Args) => Result) | undefined) => {
@@ -81,6 +83,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
         if (answer.isPlaced) {
           shown.openPanes.add(pane.id)
           unplacedPanes.delete(pane.id)
+          if (pane.focus === true) focusedPane = pane.id
         } else if (!shown.openPanes.has(pane.id)) {
           unplacedPanes.add(pane.id)
         }
@@ -90,11 +93,13 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
         calls.push({ call: 'ui.close', args: [pane] })
         shown.openPanes.delete(pane.id)
         unplacedPanes.delete(pane.id)
+        if (focusedPane === pane.id) focusedPane = undefined
       },
       panes: async () => [
-        ...[...shown.openPanes].map((id) => ({ id, title: id, isShown: true, isFocused: false, isPlaced: true })),
+        ...[...shown.openPanes].map((id) => ({ id, title: id, isShown: true, isFocused: id === focusedPane, isPlaced: true })),
         ...[...unplacedPanes].map((id) => ({ id, title: id, isShown: false, isFocused: false, isPlaced: false })),
       ],
+      scroll: rejected('ui.scroll', () => fakes.ui.scroll ?? (async () => ({}))),
       resolve: () => elements,
     },
     process: {
@@ -110,7 +115,10 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
     },
     http: { fetch: rejected('http.fetch', () => fakes.http.fetch) },
     settings: { read: rejected('settings.read', () => fakes.settings.read) },
-    agent: { list: rejected('agent.list', () => fakes.agent.list) },
+    agent: {
+      list: rejected('agent.list', () => fakes.agent.list),
+      spawn: rejected('agent.spawn', () => fakes.agent.spawn),
+    },
     store: {
       get: async (key) => store.get(key),
       set: async (key, value) => {
@@ -133,6 +141,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       model: async () => 'test-model',
       usage: async () => ({ context: { window: 200000 }, rateLimits: {}, cost: { usd: 0 } }) as unknown as Awaited<ReturnType<Claude['session']['usage']>>,
       surfaces: async () => ['terminal'],
+      messages: rejected('session.messages', () => fakes.session.messages as ((args?: unknown) => Promise<unknown>) | undefined) as Claude['session']['messages'],
     },
     command: {
       register: async (command) => {

package/src/testing/fake-elements.ts

@@ -2,8 +2,6 @@ import type { ElementTable, RenderElement, RenderNode } from 'claude-code'
 
 type Drawn = { readonly type: string; readonly props: Record<string, unknown>; readonly children?: readonly RenderNode[] }
 
-type Button = { readonly type: 'Button'; readonly props: { readonly key: string; readonly label: string; readonly onPress: () => unknown } }
-
 const boxInsides = new WeakMap<object, Drawn>()
 
 function element(type: string) {
@@ -31,12 +29,12 @@ export const elements = {
   Image: element('Image'),
 } as unknown as ElementTable
 
-export function findButton(node: RenderNode, key: string): Button | undefined {
+export function findElement(node: RenderNode, type: string, key: string): Drawn['props'] | undefined {
   if (typeof node === 'string') return undefined
-  const { type, props, children = [] } = insideOf(node)
-  if (type === 'Button' && (props['key'] === key || props['label'] === key)) return node as unknown as Button
-  for (const child of children) {
-    const found = findButton(child, key)
+  const drawn = insideOf(node)
+  if (drawn.type === type && (drawn.props['key'] === key || (type === 'Button' && drawn.props['label'] === key))) return drawn.props
+  for (const child of drawn.children ?? []) {
+    const found = findElement(child, type, key)
     if (found !== undefined) return found
   }
   return undefined

package/src/testing/fake-files.ts

@@ -1,10 +1,10 @@
 import type { Claude } from '../runtime/claude.js'
-import { resolvePath } from '../utils/paths.js'
+import { resolve } from '../vendor.js'
 
 export function fakeFiles(files: Readonly<Record<string, string>>, links: Readonly<Record<string, string>> = {}): Claude['fs'] {
-  const contents = new Map(Object.entries(files).map(([path, text]) => [resolvePath(path, '/'), text]))
+  const contents = new Map(Object.entries(files).map(([path, text]) => [resolve('/', path), text]))
   const realPathOf = (path: string): string => {
-    const absolute = resolvePath(path, '/')
+    const absolute = resolve('/', path)
     for (const [link, target] of Object.entries(links)) {
       if (absolute === link || absolute.startsWith(`${link}/`)) return realPathOf(`${target}${absolute.slice(link.length)}`)
     }
@@ -35,7 +35,7 @@ export function fakeFiles(files: Readonly<Record<string, string>>, links: Readon
       if (kindOf(folder) !== 'dir') throw new Error(`ENOENT: no such directory, list '${path}'`)
       const names = new Set(below(folder).map((file) => file.split('/')[0] as string))
       return [...names].map((name) => {
-        const entry = resolvePath(name, folder)
+        const entry = resolve(folder, name)
         if (Object.hasOwn(links, entry)) return { name, kind: 'other', size: 0, mtimeMs: 0, isLink: true }
         return { name, kind: contents.has(entry) ? 'file' : 'dir', size: sizeOf(entry), mtimeMs: 0, isLink: false }
       })
@@ -44,7 +44,7 @@ export function fakeFiles(files: Readonly<Record<string, string>>, links: Readon
     stat: async (path, options) => {
       const realPath = realPathOf(path)
       const kind = kindOf(realPath)
-      const isLink = Object.hasOwn(links, resolvePath(path, '/'))
+      const isLink = Object.hasOwn(links, resolve('/', path))
       if (kind === undefined && isLink) return { kind: 'other', size: 0, mtimeMs: 0, isLink }
       if (kind === undefined) throw new Error(`ENOENT: no such file or directory, stat '${path}'`)
       return { kind, size: sizeOf(realPath), mtimeMs: 0, isLink, ...(options?.resolve === true ? { realPath } : {}) }

package/src/testing.ts

@@ -1,13 +1,31 @@
-import type { Args, ClassicHookInputs, CmodDependencies, CommandPresentation, CommandRunResult, EventResult, Frozen, PaneOpenArgs, RenderChildren, RenderComponent, RenderElement, RenderPropsOf } from 'claude-code'
+import type {
+  Args,
+  ClassicHookInputs,
+  CmodDependencies,
+  CommandPresentation,
+  CommandRunResult,
+  EventResult,
+  Frozen,
+  PaneOpenArgs,
+  PressedLink,
+  RenderChildren,
+  RenderComponent,
+  RenderElement,
+  RenderPropsOf,
+  UiInputArgument,
+  UiPressArgument,
+  UiSelectArgument,
+} from 'claude-code'
 import type { Reply } from './jobs/slash-command.js'
 import type { ModDefinition, ModEvent } from './mod.js'
 import { storeFolder } from './records.js'
 import type { Claude } from './runtime/claude.js'
 import { answerCall, notInstalled } from './runtime/dependencies.js'
 import type { RoutedEvent } from './runtime/hooks.js'
+import { toolInputOf } from './runtime/tool-calls.js'
 import { createLifecycle } from './runtime/lifecycle.js'
 import { fakeClaude, type Fakes, type Shown, type TestCall } from './testing/fake-claude.js'
-import { elements, findButton, rowsOf } from './testing/fake-elements.js'
+import { elements, findElement, rowsOf } from './testing/fake-elements.js'
 import { fakeFiles } from './testing/fake-files.js'
 import type { Slot, SlotProps } from './ui/slots.js'
 
@@ -35,7 +53,9 @@ export type TestedMod<State extends object> = {
   lines<S extends Slot<object, object, { readonly component: RenderComponent }>>(slot: S, props: Omit<SlotProps<S>, 'Default'>, requestId?: string): Promise<string[]>
   type(line: string): Promise<Reply>
   callTool(name: string, input: Record<string, unknown>): Promise<EventResult<'tool.call'>>
-  press(paneId: string, key: string): Promise<void>
+  press(paneId: string, key: string, link?: string): Promise<void>
+  input(paneId: string, key: string, text: string, kind?: UiInputArgument['kind']): Promise<void>
+  select(paneId: string, key: string, value: string): Promise<void>
   moveTo(projectRoot: string, cwd?: string): Promise<void>
   readonly state: Readonly<State>
   readonly calls: readonly TestCall[]
@@ -67,6 +87,12 @@ export function testMod<State extends object>(definition: ModDefinition<State>,
   fake.claude.session.root = async () => projectRoot
   fake.claude.session.cwd = async () => cwd
   fake.fakes.cmod.call = fakeDependencies(options.dependencies ?? {})
+  const firedAgents = new Map<string, string>()
+  const listAgents = fake.claude.agent.list
+  fake.claude.agent.list = async () => {
+    if (fake.fakes.agent.list !== undefined || firedAgents.size === 0) return listAgents()
+    return [...firedAgents].map(([id, type]) => ({ id, type, description: '', status: 'running' as const }))
+  }
   Object.assign(fake.fakes.fs, fakeFiles(options.files ?? {}))
   const starting = options.state as Record<string, object> | undefined
   const declared = Object.entries(definition.state ?? {}) as [string, object][]
@@ -100,11 +126,20 @@ export function testMod<State extends object>(definition: ModDefinition<State>,
     }
     const opened = fake.calls.findLast((call) => call.call === 'ui.open' && (call.args[0] as PaneOpenArgs).id === paneId)?.args[0] as PaneOpenArgs | undefined
     const columns = opened?.columns ?? defaultColumns
-    const props: RenderPropsOf['Pane'] = { title: opened?.title ?? paneId, isFocused: false, bodyColumns: columns, placement: 'dock', scroll: { offset: 0, bodyRows: defaultRows }, view: {} }
+    const isFocused = (await fake.claude.ui.panes()).some((open) => open.id === paneId && open.isFocused)
+    const props: RenderPropsOf['Pane'] = { title: opened?.title ?? paneId, isFocused, bodyColumns: columns, placement: 'dock', scroll: { offset: 0, bodyRows: defaultRows }, view: {} }
     const drawing = await route('ui.render', { surface: 'terminal', component: 'Pane', requestId: paneId, props }, elements.Box({}))
     return { drawing, columns }
   }
 
+  const drawnElement = async (paneId: string, type: 'Button' | 'Input' | 'Select' | 'Markdown', key: string) => {
+    const props = findElement((await drawPane(paneId)).drawing, type, key)
+    if (props === undefined) throw new Error(`The pane "${paneId}" of ${name} draws no ${type} with the ${type === 'Button' ? 'key or label' : 'key'} "${key}".`)
+    return props
+  }
+
+  const eventIn = (paneId: string, key: string) => ({ plugin: name, element: key, component: 'Pane' as const, requestId: paneId, surface: 'terminal' as const })
+
   const drawSlot = async (component: RenderComponent, props: object, requestId = `${component}_${(slotDraws += 1)}`) => {
     await start()
     const input = { surface: 'terminal', component, requestId, props } as Frozen<Args<'ui.render'>>
@@ -121,11 +156,31 @@ export function testMod<State extends object>(definition: ModDefinition<State>,
     }
     const toolUse = toolUseEvents.includes(event) ? { tool_use_id: `toolu_${(toolUses += 1)}` } : {}
     const filled = { session_id: sessionId, transcript_path: '/test/transcript.jsonl', cwd, hook_event_name: event, ...toolUse, ...input }
-    if (event !== 'PreToolUse') return route(`classic.${event as ModEvent}`, filled, below)
-    const { tool_name, tool_input, tool_use_id } = filled as ClassicHookInputs['PreToolUse']
-    return route('classic.PreToolUse', { ...(tool_input as object), tool: tool_name, tool_use_id }, below)
+    if (event !== 'PreToolUse') return route(`classic.${event as Exclude<ModEvent, 'PreToolUse'>}`, filled, below)
+    return firePreToolUse(filled as ClassicHookInputs['PreToolUse'], below as { deny?: string } | undefined)
   }) as TestedMod<State>['fire']
 
+  const firePreToolUse = async ({ tool_name, tool_input, tool_use_id, agent_id, agent_type }: ClassicHookInputs['PreToolUse'], below: { deny?: string } | undefined) => {
+    await start()
+    if (agent_id !== undefined && agent_type !== undefined) firedAgents.set(agent_id, agent_type)
+    const envelope = { ...(tool_input as object), tool: tool_name, tool_use_id, ...(agent_id === undefined ? {} : { agentId: agent_id }) } as Frozen<Args<'tool.call'>>
+    const asks: EventResult<'tool.check'> = below?.deny === undefined ? { decision: 'ask' } : { decision: 'deny', reason: below.deny }
+    let reached = envelope
+    let check = asks
+    const answer = await lifecycle.route('tool.call', envelope, async (e) => {
+      reached = e
+      check = await lifecycle.route('tool.check', { tool: e.tool, input: toolInputOf(e), tool_use_id: e.tool_use_id, ...(e.agentId === undefined ? {} : { agentId: e.agentId }) }, async () => asks)
+      return (check.decision === 'deny' ? { deny: check.reason ?? '' } : { result: '' }) as EventResult<'tool.call'>
+    })
+    const updatedInput = toolInputOf(reached)
+    const decided = check === asks ? {} : check.decision === 'allow' ? { allow: true } : check.decision === 'ask' ? { ask: check.reason ?? '' } : {}
+    return {
+      ...(answer.deny === undefined ? decided : { deny: answer.deny }),
+      ...(JSON.stringify(updatedInput) === JSON.stringify(tool_input) ? {} : { updatedInput }),
+      ...(answer.context === undefined || answer.context.length === 0 ? {} : { additionalContext: [...answer.context] }),
+    } as EventResult<'classic.PreToolUse'>
+  }
+
   return {
     start,
     fire,
@@ -154,10 +209,27 @@ export function testMod<State extends object>(definition: ModDefinition<State>,
       if (answer === unanswered) throw new Error(`${name} has no tool ${toolName}. Add it in setup with mod.use(tool({ name: '${toolName}', … })).`)
       return answer
     },
-    async press(paneId, key) {
-      const button = findButton((await drawPane(paneId)).drawing, key)
-      if (button === undefined) throw new Error(`The pane "${paneId}" of ${name} draws no Button with the key or label "${key}".`)
-      await button.props.onPress()
+    async press(paneId, key, link) {
+      const props = await drawnElement(paneId, link === undefined ? 'Button' : 'Markdown', key)
+      if (link !== undefined && props['onLinkPress'] === undefined) throw new Error(`The Markdown "${key}" in the pane "${paneId}" of ${name} has no onLinkPress, so Claude Code opens its links itself.`)
+      const pressed: UiPressArgument = { ...eventIn(paneId, String(props['key'])), ...(link === undefined ? {} : { link: { href: link } }) }
+      await lifecycle.route('ui.press', pressed as Frozen<Args<'ui.press'>>, async (e) => {
+        if (e.link === undefined) await (props['onPress'] as (e: UiPressArgument) => unknown)(e)
+        else await (props['onLinkPress'] as (link: PressedLink, e: UiPressArgument) => unknown)(e.link, e)
+        return { element: e.element }
+      })
+    },
+    async input(paneId, key, text, kind = 'submit') {
+      const props = await drawnElement(paneId, 'Input', key)
+      const typed: UiInputArgument = { ...eventIn(paneId, key), kind, value: text }
+      await (props[kind === 'submit' ? 'onSubmit' : 'onInput'] as ((value: string, e: UiInputArgument) => unknown) | undefined)?.(text, typed)
+    },
+    async select(paneId, key, value) {
+      const props = await drawnElement(paneId, 'Select', key)
+      const options = (props['options'] as readonly { readonly value: string }[]).map((option) => option.value)
+      if (!options.includes(value)) throw new Error(`The Select "${key}" in the pane "${paneId}" of ${name} has no option "${value}". Its options are ${options.map((option) => `"${option}"`).join(', ')}.`)
+      const picked: UiSelectArgument = { ...eventIn(paneId, key), value }
+      await (props['onSelect'] as (value: string, e: UiSelectArgument) => unknown)(value, picked)
     },
     async moveTo(nextRoot, nextCwd = nextRoot) {
       await start()