@cmodjs/core 0.1.8 → 0.1.9

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()

package/src/ui/define-pane.ts

@@ -1,4 +1,4 @@
-import type { Frozen, RenderElement, RenderPropsOf } from 'claude-code'
+import type { Frozen, PaneCloseInput, RenderElement, RenderPropsOf, UiScrollInput } from 'claude-code'
 import type { Mod } from '../mod.js'
 
 export type Pane<State extends object = Record<never, never>> = {
@@ -6,7 +6,11 @@ export type Pane<State extends object = Record<never, never>> = {
   readonly title: string
   readonly columns?: number | ((state: State) => number | undefined)
   readonly rows?: number | ((state: State) => number | undefined)
+  readonly closeOnEscape?: true
+  readonly holdToasts?: true
   render(mod: Mod<State>, props: Frozen<RenderPropsOf['Pane']>): RenderElement
+  onScroll?(mod: Mod<State>, e: Frozen<UiScrollInput>): void | Promise<void>
+  onClose?(mod: Mod<State>, e: Frozen<PaneCloseInput>): void | Promise<void>
 }
 
 const paneId = /^[A-Za-z0-9_-]{1,64}$/

package/src/utils/call-effects.ts

@@ -1,5 +1,6 @@
-import { parseShellCommands, type ShellCommand } from './parse-shell.js'
-import { expandHome, resolvePath, type FileSystem } from './paths.js'
+import { parseShell, type ShellCommand } from './parse-shell.js'
+import { expandHome, type FileSystem } from './paths.js'
+import { resolve } from '../vendor.js'
 
 export type ToolUse = { tool: string; input: unknown; agentId?: string; agentType?: string }
 
@@ -21,13 +22,13 @@ export type CallEffects = {
 
 export function callEffects(use: ToolUse, workspace: { cwd: string; home: string; fs: FileSystem }): CallEffects {
   const { fs } = workspace
-  const resolve = (path: string, folder = workspace.cwd) => resolvePath(expandHome(path, workspace.home), folder)
-  const access = (path: string): FileAccess => ({ path: resolve(path), contents: undefined })
+  const absolute = (path: string, folder = workspace.cwd) => resolve(folder, expandHome(path, workspace.home))
+  const access = (path: string): FileAccess => ({ path: absolute(path), contents: undefined })
   const effects: CallEffects = { shell: undefined, reads: [], writes: [], urls: [], subagent: undefined }
   if (use.tool === 'Bash') {
     const line = textField(use, 'command')
-    const parsed = parseShellCommands(line)
-    const commands = parsed.commands.map(({ argv, folder }) => ({ argv, folder: resolve(folder) }))
+    const parsed = parseShell(line)
+    const commands = parsed.commands.map(({ argv, folder }) => ({ argv, folder: absolute(folder) }))
     effects.shell = { line, commands, isFullyParsed: parsed.isFullyParsed }
     effects.reads = parsed.reads.map(access)
     effects.writes = parsed.writes.map(access)
@@ -35,22 +36,22 @@ export function callEffects(use: ToolUse, workspace: { cwd: string; home: string
   } else if (use.tool === 'PowerShell') {
     effects.shell = { line: textField(use, 'command'), commands: [], isFullyParsed: false }
   } else if (use.tool === 'Edit') {
-    const path = resolve(textField(use, 'file_path'))
+    const path = absolute(textField(use, 'file_path'))
     effects.writes = [{ path, contents: once(() => editedContents(use, path, fs)) }]
   } else if (use.tool === 'Write') {
-    const path = resolve(textField(use, 'file_path'))
+    const path = absolute(textField(use, 'file_path'))
     const content = textField(use, 'content')
     effects.writes = [{ path, contents: once(async () => contentsOf(content, await previousContentOf(path, fs))) }]
   } else if (use.tool === 'NotebookEdit') {
-    const path = resolve(textField(use, 'notebook_path'))
+    const path = absolute(textField(use, 'notebook_path'))
     effects.writes = [{ path, contents: once(async () => contentsOf(undefined, await previousContentOf(path, fs))) }]
   } else if (use.tool === 'Read') {
     effects.reads = [access(textField(use, 'file_path'))]
   } else if (use.tool === 'Grep') {
     effects.reads = [access(optionalTextField(use, 'path') ?? '')]
   } else if (use.tool === 'Glob') {
-    const folder = resolve(optionalTextField(use, 'path') ?? '')
-    effects.reads = [{ path: resolve(textField(use, 'pattern'), folder), contents: undefined }]
+    const folder = absolute(optionalTextField(use, 'path') ?? '')
+    effects.reads = [{ path: absolute(textField(use, 'pattern'), folder), contents: undefined }]
   } else if (use.tool === 'WebFetch') {
     effects.urls = [textField(use, 'url')]
   } else if (use.tool === 'Agent') {

package/src/utils/parse-shell.ts

@@ -1,18 +1,15 @@
-import { nameOf } from './paths.js'
-import { parse, type GlobPattern, type ParseEntry } from '../vendor.js'
+import { basename, parse, type GlobPattern, type ParseEntry } from '../vendor.js'
+
+export type ShellCommand = { argv: [string, ...string[]]; folder: string }
 
 export type ParsedShell = {
-  commands: [string, ...string[]][]
+  commands: ShellCommand[]
   writes: string[]
   reads: string[]
   fetches: string[]
   isFullyParsed: boolean
 }
 
-export type ShellCommand = { argv: [string, ...string[]]; folder: string }
-
-export type ParsedShellCommands = Omit<ParsedShell, 'commands'> & { commands: ShellCommand[] }
-
 type Word = { text: string; isGlob: boolean; isDynamic: boolean }
 type Marker = { raw: string; code: string[] }
 type Expansion = Marker & { end: number }
@@ -200,17 +197,12 @@ const inlineCodeFlags = new Map<string, readonly string[]>([
 ])
 
 export function parseShell(line: string): ParsedShell {
-  const parsed = parseShellCommands(line)
-  return { ...parsed, commands: parsed.commands.map((command) => command.argv) }
-}
-
-export function parseShellCommands(line: string): ParsedShellCommands {
-  const result: ParsedShellCommands = { commands: [], writes: [], reads: [], fetches: [], isFullyParsed: true }
+  const result: ParsedShell = { commands: [], writes: [], reads: [], fetches: [], isFullyParsed: true }
   parseLine(line, '', result)
   return result
 }
 
-function parseLine(line: string, folder: string, result: ParsedShellCommands): void {
+function parseLine(line: string, folder: string, result: ParsedShell): void {
   if (line.includes('\u0001')) {
     result.isFullyParsed = false
     return
@@ -475,7 +467,7 @@ function readHeredocBodies(source: string, from: number, heredocs: Heredoc[]): n
   return index
 }
 
-function walk(tokens: ParseEntry[], markers: Marker[], start: string, result: ParsedShellCommands): void {
+function walk(tokens: ParseEntry[], markers: Marker[], start: string, result: ParsedShell): void {
   let folder = start
   const subshells: string[] = []
   let command = newCommand(false)
@@ -533,7 +525,7 @@ function isWordToken(token: ParseEntry): token is string | GlobPattern {
   return typeof token === 'string' || ('op' in token && token.op === 'glob')
 }
 
-function wordOf(token: string | GlobPattern, markers: Marker[], folder: string, result: ParsedShellCommands): Word {
+function wordOf(token: string | GlobPattern, markers: Marker[], folder: string, result: ParsedShell): Word {
   const raw = typeof token === 'string' ? token : token.pattern
   for (const match of raw.matchAll(markerPattern)) {
     for (const code of markers[Number(match[1])]!.code) parseLine(code, folder, result)
@@ -541,11 +533,11 @@ function wordOf(token: string | GlobPattern, markers: Marker[], folder: string,
   return {
     text: raw.replace(markerPattern, (_, index: string) => markers[Number(index)]!.raw),
     isGlob: typeof token !== 'string',
-    isDynamic: /[$\u0001]/.test(nameOf(raw)),
+    isDynamic: /[$\u0001]/.test(basename(raw)),
   }
 }
 
-function finish(command: Command, operator: string, folder: string, result: ParsedShellCommands): string {
+function finish(command: Command, operator: string, folder: string, result: ParsedShell): string {
   for (const redirect of command.redirects) addRedirect(redirect, folder, result)
   const words = withoutPrefixes(command.words)
   const [first, ...args] = words
@@ -569,14 +561,14 @@ function withoutPrefixes(words: Word[]): Word[] {
   return words.slice(start)
 }
 
-function addRedirect({ operator, target }: Redirect, folder: string, result: ParsedShellCommands): void {
+function addRedirect({ operator, target }: Redirect, folder: string, result: ParsedShell): void {
   if (operator === '<' || operator === '<>') addPath(result, 'reads', target, folder)
   if (writeRedirects.has(operator) || (operator === '>&' && !/^([0-9]+|-)$/.test(target.text))) addPath(result, 'writes', target, folder)
 }
 
-function addCommand(first: Word, args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShellCommands): string | undefined {
+function addCommand(first: Word, args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShell): string | undefined {
   if (first.isDynamic || first.isGlob) result.isFullyParsed = false
-  const program = nameOf(first.text)
+  const program = basename(first.text)
   if (program === 'git') addGit(first, args, folder, result)
   else if (program === 'find') addFind(first, args, folder, result)
   else if (wrappers.has(program)) addWrapper(first, program, args, folder, stdin, result)
@@ -589,7 +581,7 @@ function addCommand(first: Word, args: Word[], folder: string, stdin: Stdin | un
   return undefined
 }
 
-function addGit(first: Word, args: Word[], folder: string, result: ParsedShellCommands): void {
+function addGit(first: Word, args: Word[], folder: string, result: ParsedShell): void {
   let index = 0
   let gitFolder = folder
   for (let text = args[0]?.text; text?.startsWith('-') === true; text = args[index]?.text) {
@@ -600,7 +592,7 @@ function addGit(first: Word, args: Word[], folder: string, result: ParsedShellCo
   result.commands.push({ argv: [first.text, ...expandFlags('git', args.slice(index))], folder: gitFolder })
 }
 
-function addFind(first: Word, args: Word[], folder: string, result: ParsedShellCommands): void {
+function addFind(first: Word, args: Word[], folder: string, result: ParsedShell): void {
   const own: string[] = []
   const actions: Word[][] = []
   for (let index = 0; index < args.length; index += 1) {
@@ -628,7 +620,7 @@ function findStarts(args: Word[]): Word[] {
   return starts.length > 0 ? starts : [literal('.')]
 }
 
-function addWrapper(first: Word, program: string, args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShellCommands): void {
+function addWrapper(first: Word, program: string, args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShell): void {
   const wrapper = wrappers.get(program)!
   if (program === 'xargs' && stdin?.kind !== 'text') result.isFullyParsed = false
   const { options, operands } = readArguments(args, wrapper, true)
@@ -651,7 +643,7 @@ function addWrapper(first: Word, program: string, args: Word[], folder: string,
   if (innerFirst !== undefined) addCommand(innerFirst, innerArgs, wrappedFolder, stdin, result)
 }
 
-function addEffects(program: string, args: Word[], flags: string[], folder: string, stdin: Stdin | undefined, result: ParsedShellCommands): void {
+function addEffects(program: string, args: Word[], flags: string[], folder: string, stdin: Stdin | undefined, result: ParsedShell): void {
   const fileProgram = fileReaders.get(program)
   const fileWriter = fileWriters.get(program)
   const copyProgram = copyPrograms.get(program)
@@ -675,7 +667,7 @@ function addEffects(program: string, args: Word[], flags: string[], folder: stri
   }
 }
 
-function addShell(args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShellCommands): void {
+function addShell(args: Word[], folder: string, stdin: Stdin | undefined, result: ParsedShell): void {
   const { options, operands } = readArguments(args, { valued: 'oO', longValued: ['--rcfile', '--init-file'] }, true)
   const script = operands[0]
   if (options.some((option) => option.name === '-c')) {
@@ -683,35 +675,35 @@ function addShell(args: Word[], folder: string, stdin: Stdin | undefined, result
   } else if (script === undefined || options.some((option) => option.name === '-s')) addStdinCode(stdin, folder, result)
 }
 
-function addSsh(args: Word[], stdin: Stdin | undefined, result: ParsedShellCommands): void {
+function addSsh(args: Word[], stdin: Stdin | undefined, result: ParsedShell): void {
   const { operands } = readArguments(args, { valued: 'BbcDEeFIiJLlmOoPpQRSWw' }, true)
   const remote = operands.slice(1)
   if (remote.length > 0) parseLine(remote.map((word) => word.text).join(' '), '~', result)
   else if (operands.length > 0) addStdinCode(stdin, '~', result)
 }
 
-function addSu(args: Word[], folder: string, result: ParsedShellCommands): void {
+function addSu(args: Word[], folder: string, result: ParsedShell): void {
   const code = readArguments(args, su, false).options.findLast((option) => suCodeOptions.includes(option.name))?.value
   if (code !== undefined) parseLine(code.text, folder, result)
 }
 
-function addFetches(fetcher: OptionSpec, args: Word[], result: ParsedShellCommands): void {
+function addFetches(fetcher: OptionSpec, args: Word[], result: ParsedShell): void {
   const { options, operands } = readArguments(args, fetcher, false)
   const urls = [...options.filter((option) => option.name === '--url').flatMap((option) => (option.value === undefined ? [] : [option.value])), ...operands]
   for (const url of urls) result.fetches.push(/^[a-z][a-z0-9+.-]*:\/\//i.test(url.text) ? url.text : `http://${url.text}`)
 }
 
-function addStdinCode(stdin: Stdin | undefined, folder: string, result: ParsedShellCommands): void {
+function addStdinCode(stdin: Stdin | undefined, folder: string, result: ParsedShell): void {
   if (stdin?.kind === 'text') parseLine(stdin.text, folder, result)
   if (stdin?.kind === 'pipe') result.isFullyParsed = false
 }
 
-function addCopy(program: CopyProgram, args: Word[], folder: string, result: ParsedShellCommands): void {
+function addCopy(program: CopyProgram, args: Word[], folder: string, result: ParsedShell): void {
   const { options, operands } = readArguments(args, program, false)
   const target = options.findLast((option) => program.targetOptions?.includes(option.name) === true)?.value
   const only = operands[0]
   if (program.linksHere === true && target === undefined && operands.length === 1 && only !== undefined) {
-    addPath(result, 'writes', { ...only, text: nameOf(only.text) }, folder)
+    addPath(result, 'writes', { ...only, text: basename(only.text) }, folder)
     return
   }
   const destination = target ?? operands.at(-1)
@@ -720,12 +712,12 @@ function addCopy(program: CopyProgram, args: Word[], folder: string, result: Par
   const isLocal = (word: Word) => program.skipsRemote !== true || !/^[^/]*:/.test(word.text)
   for (const source of sources.filter(isLocal)) {
     if (program.sources !== undefined) addPath(result, program.sources, source, folder)
-    if (isLocal(destination) && !source.isGlob && !destination.isGlob) addPathText(result, 'writes', `${destination.text.replace(/\/+$/, '')}/${nameOf(source.text)}`, folder)
+    if (isLocal(destination) && !source.isGlob && !destination.isGlob) addPathText(result, 'writes', `${destination.text.replace(/\/+$/, '')}/${basename(source.text)}`, folder)
   }
   if (isLocal(destination)) addPath(result, 'writes', destination, folder)
 }
 
-function addFileArguments(program: FileProgram, args: Word[], folder: string, result: ParsedShellCommands): void {
+function addFileArguments(program: FileProgram, args: Word[], folder: string, result: ParsedShell): void {
   const { options, operands } = readArguments(args, program, false)
   const inPlace = options.find((option) => program.inPlaceOptions?.includes(option.name) === true && (program !== awk || option.value?.text === 'inplace'))
   let files = operands
@@ -812,11 +804,11 @@ function changedFolder(args: Word[], folder: string): string {
   return joinFolder(folder, target.text === '-' ? '$OLDPWD' : target.text)
 }
 
-function addPath(result: ParsedShellCommands, access: Access, word: Word | undefined, folder: string): void {
+function addPath(result: ParsedShell, access: Access, word: Word | undefined, folder: string): void {
   if (word !== undefined && !word.isGlob) addPathText(result, access, word.text, folder)
 }
 
-function addPathText(result: ParsedShellCommands, access: Access, path: string, folder: string): void {
+function addPathText(result: ParsedShell, access: Access, path: string, folder: string): void {
   if (path === '' || path.startsWith('/dev/')) return
   const joined = joinFolder(folder, path)
   if (dynamicPattern.test(joined.replace(homePrefix, ''))) result.isFullyParsed = false

package/src/utils/paths.ts

@@ -1,3 +1,5 @@
+import { basename, dirname, resolve } from '../vendor.js'
+
 export type FileSystem = {
   read: (path: string) => Promise<string>
   stat: (path: string) => Promise<{ kind: 'file' | 'dir' | 'other'; realPath?: string }>
@@ -9,23 +11,6 @@ export function expandHome(path: string, home: string): string {
   return prefix === undefined ? path : `${home}${path.slice(prefix.length)}`
 }
 
-export function resolvePath(path: string, folder: string): string {
-  const parts: string[] = []
-  for (const part of (path.startsWith('/') ? path : `${folder}/${path}`).split('/')) {
-    if (part === '..') parts.pop()
-    else if (part !== '' && part !== '.') parts.push(part)
-  }
-  return `/${parts.join('/')}`
-}
-
-export function parentOf(path: string): string {
-  return resolvePath('..', path)
-}
-
-export function nameOf(path: string): string {
-  return path.slice(path.lastIndexOf('/') + 1)
-}
-
 export function relativePath(base: string, path: string): string | undefined {
   if (path === base) return ''
   const prefix = base === '/' ? '/' : `${base}/`
@@ -35,6 +20,6 @@ export function relativePath(base: string, path: string): string | undefined {
 export async function realPathOf(path: string, fs: FileSystem): Promise<string | undefined> {
   const stat = await fs.stat(path).catch(() => undefined)
   if (stat !== undefined || path === '/') return stat?.realPath
-  const folder = await realPathOf(parentOf(path), fs)
-  return folder === undefined ? undefined : resolvePath(nameOf(path), folder)
+  const folder = await realPathOf(dirname(path), fs)
+  return folder === undefined ? undefined : resolve(folder, basename(path))
 }

package/src/vendor.ts

@@ -1,3 +1,4 @@
 export { Validator } from '@cfworker/json-schema'
+export { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve } from 'pathe'
 export { default as picomatch } from 'picomatch/posix'
 export { parse, quote, type GlobPattern, type ParseEntry } from 'shell-quote'

package/testing/fake-claude.d.ts

@@ -24,9 +24,14 @@ export type Fakes = {
     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'];

package/testing/fake-claude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fake-claude.d.ts","sourceRoot":"","sources":["../src/testing/fake-claude.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fake-claude.d.ts","sourceRoot":"","sources":["../src/testing/fake-claude.ts"],"names":[],"mappings":"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"}

package/testing/fake-claude.js

@@ -1,9 +1,10 @@
 import { elements } from './fake-elements.js';
 export function fakeClaude(plugin) {
     const calls = [];
-    const fakes = { process: {}, fs: {}, http: {}, settings: {}, ui: {}, agent: {}, clock: {}, cmod: {} };
+    const fakes = { process: {}, fs: {}, http: {}, settings: {}, ui: {}, session: {}, agent: {}, clock: {}, cmod: {} };
     const shown = { toasts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [] };
     const unplacedPanes = new Set();
+    let focusedPane;
     const store = new Map();
     const faked = (call, answer) => {
         return (...args) => {
@@ -41,6 +42,8 @@ export function fakeClaude(plugin) {
                 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);
@@ -51,11 +54,14 @@ export function fakeClaude(plugin) {
                 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: {
@@ -71,7 +77,10 @@ export function fakeClaude(plugin) {
         },
         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) => {
@@ -94,6 +103,7 @@ export function fakeClaude(plugin) {
             model: async () => 'test-model',
             usage: async () => ({ context: { window: 200000 }, rateLimits: {}, cost: { usd: 0 } }),
             surfaces: async () => ['terminal'],
+            messages: rejected('session.messages', () => fakes.session.messages),
         },
         command: {
             register: async (command) => {

package/testing/fake-elements.d.ts

@@ -1,14 +1,11 @@
 import type { ElementTable, RenderNode } from 'claude-code';
-type Button = {
-    readonly type: 'Button';
-    readonly props: {
-        readonly key: string;
-        readonly label: string;
-        readonly onPress: () => unknown;
-    };
+type Drawn = {
+    readonly type: string;
+    readonly props: Record<string, unknown>;
+    readonly children?: readonly RenderNode[];
 };
 export declare const elements: ElementTable;
-export declare function findButton(node: RenderNode, key: string): Button | undefined;
+export declare function findElement(node: RenderNode, type: string, key: string): Drawn['props'] | undefined;
 export declare function rowsOf(node: RenderNode, width: number): string[];
 export declare function textOf(node: RenderNode): string;
 export {};