incur 0.4.0 → 0.4.2

package/src/Help.test.ts

@@ -1,5 +1,43 @@
 import { Help, z } from 'incur'
 
+describe('redact: short secrets should not leak characters', () => {
+  /**
+   * The internal `redact()` function is exercised through `formatCommand`
+   * by passing an env schema + envSource with a set value.
+   */
+  function getRedactedValue(secret: string): string {
+    const env = z.object({ SECRET: z.string().describe('a secret') })
+    const output = Help.formatCommand('test', {
+      env,
+      envSource: { SECRET: secret },
+      hideGlobalOptions: true,
+    })
+    const match = output.match(/set:\s*(\S+)/)
+    if (!match) throw new Error(`Could not find "set:" in output:\n${output}`)
+    return match[1]!
+  }
+
+  test('1-char secret is fully masked', () => {
+    const redacted = getRedactedValue('x')
+    expect(redacted).not.toContain('x')
+  })
+
+  test('2-char secret does not leak any character', () => {
+    const redacted = getRedactedValue('ab')
+    expect(redacted).not.toContain('b')
+  })
+
+  test('3-char secret does not leak any character', () => {
+    const redacted = getRedactedValue('abc')
+    expect(redacted).not.toContain('c')
+  })
+
+  test('4-char secret does not leak any character', () => {
+    const redacted = getRedactedValue('wxyz')
+    expect(redacted).not.toContain('z')
+  })
+})
+
 describe('formatCommand', () => {
   test('formats leaf command with args and options', () => {
     const result = Help.formatCommand('gh pr list', {
@@ -27,13 +65,13 @@ describe('formatCommand', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
@@ -49,13 +87,13 @@ describe('formatCommand', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
@@ -78,16 +116,27 @@ describe('formatCommand', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
+  test('synopsis uses key name for non-union args and expanded values for enums', () => {
+    const result = Help.formatCommand('tool run', {
+      args: z.object({
+        port: z.number().describe('Port number'),
+        verbose: z.boolean().optional().describe('Verbose'),
+        mode: z.enum(['fast', 'slow']).describe('Mode'),
+      }),
+    })
+    expect(result).toContain('Usage: tool run <port> [verbose] <fast|slow>')
+  })
+
   test('shows count type in help for meta count', () => {
     const result = Help.formatCommand('tool run', {
       options: z.object({
@@ -99,6 +148,55 @@ describe('formatCommand', () => {
     expect(result).toContain('Verbosity level')
   })
 
+  test('omits value placeholders for boolean flag options', () => {
+    const result = Help.formatCommand('tool deploy', {
+      options: z.object({
+        dryRun: z.boolean().optional().describe('Preview without submitting.'),
+      }),
+    })
+
+    const line = result.split('\n').find((line) => line.includes('--dry-run'))
+
+    expect(line).toBe('  --dry-run  Preview without submitting.')
+  })
+
+  test('omits value placeholders for aliased boolean flag options', () => {
+    const result = Help.formatCommand('tool deploy', {
+      options: z.object({
+        dryRun: z.boolean().optional().describe('Preview without submitting.'),
+      }),
+      alias: { dryRun: 'd' },
+    })
+
+    const line = result.split('\n').find((line) => line.includes('--dry-run'))
+
+    expect(line).toBe('  --dry-run, -d  Preview without submitting.')
+  })
+
+  test('omits default false for boolean flag options', () => {
+    const result = Help.formatCommand('tool deploy', {
+      options: z.object({
+        dryRun: z.boolean().default(false).describe('Preview without submitting.'),
+      }),
+    })
+
+    const line = result.split('\n').find((line) => line.includes('--dry-run'))
+
+    expect(line).toBe('  --dry-run  Preview without submitting.')
+  })
+
+  test('shows default true for boolean flag options', () => {
+    const result = Help.formatCommand('tool deploy', {
+      options: z.object({
+        watch: z.boolean().default(true).describe('Watch for changes.'),
+      }),
+    })
+
+    const line = result.split('\n').find((line) => line.includes('--watch'))
+
+    expect(line).toBe('  --watch  Watch for changes. (default: true)')
+  })
+
   test('shows enum values for z.enum options', () => {
     const result = Help.formatCommand('tool deploy', {
       options: z.object({
@@ -130,6 +228,36 @@ describe('formatCommand', () => {
     expect(result).toContain('[deprecated] Availability zone')
     expect(result).not.toContain('[deprecated] Target region')
   })
+
+  test('shows config global options when flag name is set', () => {
+    const result = Help.formatCommand('tool deploy', {
+      configFlag: 'config',
+      options: z.object({
+        env: z.enum(['staging', 'production']).describe('Target environment'),
+      }),
+    })
+    expect(result).toMatchInlineSnapshot(`
+      "tool deploy
+
+      Usage: tool deploy [options]
+
+      Options:
+        --env <staging|production>  Target environment
+
+      Global Options:
+        --config <path>                     Load JSON option defaults from a file
+        --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
+        --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
+        --help                              Show help
+        --llms, --llms-full                 Print LLM-readable manifest
+        --no-config                         Disable JSON option defaults for this run
+        --schema                            Show JSON Schema for command
+        --token-count                       Print token count of output (instead of output)
+        --token-limit <n>                   Limit output to n tokens
+        --token-offset <n>                  Skip first n tokens of output"
+    `)
+  })
 })
 
 describe('formatRoot', () => {
@@ -155,13 +283,13 @@ describe('formatRoot', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
@@ -180,13 +308,13 @@ describe('formatRoot', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
@@ -209,13 +337,13 @@ describe('formatRoot', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
-        --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --token-offset <n>                  Skip first n tokens of output"
     `)
   })
 
@@ -238,13 +366,49 @@ describe('formatRoot', () => {
       Global Options:
         --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
         --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
+        --help                              Show help
+        --llms, --llms-full                 Print LLM-readable manifest
+        --schema                            Show JSON Schema for command
+        --token-count                       Print token count of output (instead of output)
+        --token-limit <n>                   Limit output to n tokens
+        --token-offset <n>                  Skip first n tokens of output"
+    `)
+  })
+
+  test('formatRoot shows config global options when flag name is set', () => {
+    const result = Help.formatRoot('tool', {
+      configFlag: 'config',
+      root: true,
+      commands: [{ name: 'ping', description: 'Health check' }],
+    })
+    expect(result).toMatchInlineSnapshot(`
+      "tool
+
+      Usage: tool <command>
+
+      Commands:
+        ping  Health check
+
+      Integrations:
+        completions  Generate shell completion script
+        mcp add      Register as MCP server
+        skills       Sync skill files to agents (add, list)
+
+      Global Options:
+        --config <path>                     Load JSON option defaults from a file
+        --filter-output <keys>              Filter output by key paths (e.g. foo,bar.baz,a[0,3])
+        --format <toon|json|yaml|md|jsonl>  Output format
+        --full-output                       Show full output envelope
         --help                              Show help
         --llms, --llms-full                 Print LLM-readable manifest
-        --schema                            Show JSON Schema for a command
+        --mcp                               Start as MCP stdio server
+        --no-config                         Disable JSON option defaults for this run
+        --schema                            Show JSON Schema for command
         --token-count                       Print token count of output (instead of output)
         --token-limit <n>                   Limit output to n tokens
         --token-offset <n>                  Skip first n tokens of output
-        --verbose                           Show full output envelope"
+        --version                           Show version"
     `)
   })
 })

package/src/Help.ts

@@ -1,8 +1,12 @@
 import { z } from 'zod'
 
+import { builtinCommands } from './internal/command.js'
+import { toKebab } from './internal/helpers.js'
+import { defaultEnvSource } from './Parser.js'
+
 /** Formats help text for a router CLI or command group. */
 export function formatRoot(name: string, options: formatRoot.Options = {}): string {
-  const { aliases, description, version, commands = [], root = false } = options
+  const { aliases, configFlag, description, version, commands = [], root = false } = options
   const lines: string[] = []
 
   // Header
@@ -27,7 +31,7 @@ export function formatRoot(name: string, options: formatRoot.Options = {}): stri
     }
   }
 
-  lines.push(...globalOptionsLines(root))
+  lines.push(...globalOptionsLines(root, configFlag))
 
   return lines.join('\n')
 }
@@ -36,6 +40,8 @@ export declare namespace formatRoot {
   type Options = {
     /** Alternative binary names for this CLI. */
     aliases?: string[] | undefined
+    /** Flag name for config file path (e.g. `'config'` renders `--config <path>`). */
+    configFlag?: string | undefined
     /** Commands to list. */
     commands?: { name: string; description?: string | undefined }[] | undefined
     /** A short description of the CLI or group. */
@@ -50,11 +56,13 @@ export declare namespace formatRoot {
 export declare namespace formatCommand {
   type Options = {
     /** Map of option names to single-char aliases. */
-    alias?: Record<string, string> | undefined
+    alias?: Partial<Record<string, string>> | undefined
     /** Alternative binary names for this CLI. */
     aliases?: string[] | undefined
     /** Zod schema for positional arguments. */
     args?: z.ZodObject<any> | undefined
+    /** Flag name for config file path (e.g. `'config'` renders `--config <path>`). */
+    configFlag?: string | undefined
     /** Subcommands to list (for CLIs with both a root handler and subcommands). */
     commands?: { name: string; description?: string | undefined }[] | undefined
     /** A short description of what the command does. */
@@ -67,6 +75,8 @@ export declare namespace formatCommand {
     examples?: { command: string; description?: string }[] | undefined
     /** Plain text hint displayed after examples and before global options. */
     hint?: string | undefined
+    /** Hide global options section. */
+    hideGlobalOptions?: boolean | undefined
     /** Zod schema for named options/flags. */
     options?: z.ZodObject<any> | undefined
     /** Show root-level built-in commands and flags. */
@@ -90,6 +100,7 @@ export function formatCommand(name: string, options: formatCommand.Options = {})
   const {
     alias,
     aliases,
+    configFlag,
     description,
     version,
     args,
@@ -195,7 +206,7 @@ export function formatCommand(name: string, options: formatCommand.Options = {})
     }
   }
 
-  lines.push(...globalOptionsLines(root))
+  if (!options.hideGlobalOptions) lines.push(...globalOptionsLines(root, configFlag))
 
   // Environment Variables
   if (env) {
@@ -207,7 +218,7 @@ export function formatCommand(name: string, options: formatCommand.Options = {})
       for (const entry of entries) {
         const padding = ' '.repeat(maxLen - entry.name.length)
         const parts: string[] = [entry.description]
-        const source = envSource ?? process.env
+        const source = envSource ?? defaultEnvSource()
         if (entry.name in source) parts.push(`set: ${redact(source[entry.name]!)}`)
         if (entry.defaultValue !== undefined) parts.push(`default: ${entry.defaultValue}`)
         const desc = parts.length > 1 ? `${parts[0]} (${parts.slice(1).join(', ')})` : parts[0]
@@ -223,8 +234,11 @@ export function formatCommand(name: string, options: formatCommand.Options = {})
 function buildSynopsis(name: string, args?: z.ZodObject<any>): string {
   if (!args) return name
   const parts = [name]
-  for (const [key, schema] of Object.entries(args.shape))
-    parts.push((schema as z.ZodType)._zod.optout === 'optional' ? `[${key}]` : `<${key}>`)
+  for (const [key, schema] of Object.entries(args.shape)) {
+    const type = resolveTypeName(schema)
+    const label = type.includes('|') ? type : key
+    parts.push((schema as z.ZodType)._zod.optout === 'optional' ? `[${label}]` : `<${label}>`)
+  }
   return parts.join(' ')
 }
 
@@ -247,7 +261,10 @@ function envEntries(schema: z.ZodObject<any>) {
 }
 
 /** Extracts option entries from a Zod object schema. */
-function optionEntries(schema: z.ZodObject<any>, alias?: Record<string, string> | undefined) {
+function optionEntries(
+  schema: z.ZodObject<any>,
+  alias?: Partial<Record<string, string>> | undefined,
+) {
   const entries: {
     flag: string
     description: string
@@ -258,8 +275,10 @@ function optionEntries(schema: z.ZodObject<any>, alias?: Record<string, string>
     const type = resolveTypeName(field)
     const short = alias?.[key]
     const kebab = toKebab(key)
-    const flag = short ? `--${kebab}, -${short} <${type}>` : `--${kebab} <${type}>`
-    const defaultValue = extractDefault(field)
+    const valueHint = type === 'boolean' ? '' : ` <${type}>`
+    const flag = short ? `--${kebab}, -${short}${valueHint}` : `--${kebab}${valueHint}`
+    let defaultValue = extractDefault(field)
+    if (type === 'boolean' && defaultValue === false) defaultValue = undefined
     const deprecated = extractDeprecated(field)
     entries.push({ flag, description: (field as any).description ?? '', defaultValue, deprecated })
   }
@@ -320,30 +339,32 @@ function extractDeprecated(schema: unknown): boolean | undefined {
   return meta?.deprecated === true ? true : undefined
 }
 
-/** Converts a camelCase string to kebab-case. */
-function toKebab(str: string): string {
-  return str.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)
-}
-
 /** Renders the built-in commands and global options block. Root-only items are hidden for subcommands. */
-function globalOptionsLines(root = false): string[] {
+function globalOptionsLines(root = false, configFlag?: string): string[] {
   const lines: string[] = []
 
   if (root) {
-    const builtins = [
-      { name: 'completions', desc: 'Generate shell completion script' },
-      { name: 'mcp add', desc: 'Register as an MCP server' },
-      { name: 'skills add', desc: 'Sync skill files to your agent' },
-    ]
+    const builtins = builtinCommands.flatMap((b) => {
+      if (!b.subcommands) return [{ name: b.name, desc: b.description }]
+      if (b.subcommands.length === 1)
+        return [
+          { name: `${b.name} ${b.subcommands[0]!.name}`, desc: b.subcommands[0]!.description },
+        ]
+      const names = b.subcommands.map((s) => s.name).join(', ')
+      return [{ name: b.name, desc: `${b.description} (${names})` }]
+    })
     const maxCmd = Math.max(...builtins.map((b) => b.name.length))
     lines.push(
       '',
-      'Built-in Commands:',
+      'Integrations:',
       ...builtins.map((b) => `  ${b.name}${' '.repeat(maxCmd - b.name.length)}  ${b.desc}`),
     )
   }
 
   const flags = [
+    ...(configFlag
+      ? [{ flag: `--${configFlag} <path>`, desc: 'Load JSON option defaults from a file' }]
+      : []),
     {
       flag: '--filter-output <keys>',
       desc: 'Filter output by key paths (e.g. foo,bar.baz,a[0,3])',
@@ -352,13 +373,16 @@ function globalOptionsLines(root = false): string[] {
     { flag: '--help', desc: 'Show help' },
     { flag: '--llms, --llms-full', desc: 'Print LLM-readable manifest' },
     ...(root ? [{ flag: '--mcp', desc: 'Start as MCP stdio server' }] : []),
-    { flag: '--schema', desc: 'Show JSON Schema for a command' },
+    ...(configFlag
+      ? [{ flag: `--no-${configFlag}`, desc: 'Disable JSON option defaults for this run' }]
+      : []),
+    { flag: '--schema', desc: 'Show JSON Schema for command' },
     { flag: '--token-count', desc: 'Print token count of output (instead of output)' },
     { flag: '--token-limit <n>', desc: 'Limit output to n tokens' },
     { flag: '--token-offset <n>', desc: 'Skip first n tokens of output' },
-    { flag: '--verbose', desc: 'Show full output envelope' },
+    { flag: '--full-output', desc: 'Show full output envelope' },
     ...(root ? [{ flag: '--version', desc: 'Show version' }] : []),
-  ]
+  ].sort((a, b) => a.flag.localeCompare(b.flag))
   const maxLen = Math.max(...flags.map((f) => f.flag.length))
   lines.push(
     '',
@@ -369,8 +393,8 @@ function globalOptionsLines(root = false): string[] {
   return lines
 }
 
-/** Redacts a value, showing only the last 3 characters. */
+/** Redacts a value, showing only the last 4 characters for long values. */
 function redact(value: string): string {
-  if (value.length <= 3) return '••••'
-  return `••••${value.slice(-3)}`
+  if (value.length <= 4) return '****'
+  return `****${value.slice(-4)}`
 }

package/src/Mcp.test.ts

@@ -103,6 +103,22 @@ describe('Mcp', () => {
     expect(res.result.capabilities.tools).toBeDefined()
   })
 
+  test('initialize with 2025-03-26 protocol version', async () => {
+    const [res] = await mcpSession(createTestCommands(), [
+      {
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2025-03-26',
+          capabilities: {},
+          clientInfo: { name: 'test-client', version: '1.0.0' },
+        },
+      },
+    ])
+    expect(res.result.serverInfo).toEqual({ name: 'test-cli', version: '1.0.0' })
+    expect(res.result.capabilities.tools).toBeDefined()
+  })
+
   test('tools/list returns all leaf commands as tools', async () => {
     const [, res] = await mcpSession(createTestCommands(), [
       { id: 1, method: 'initialize', params: initParams },
@@ -216,6 +232,149 @@ describe('Mcp', () => {
     ])
   })
 
+  test('middleware runs for tool calls', async () => {
+    const commands = new Map<string, any>()
+    commands.set('secret', {
+      description: 'Protected command',
+      run: () => ({ secret: 'data' }),
+    })
+    const middlewares = [
+      async (_c: any, next: () => Promise<void>) => {
+        _c.set('ran', true)
+        await next()
+      },
+    ]
+    const input = new PassThrough()
+    const output = new PassThrough()
+    const chunks: string[] = []
+    output.on('data', (chunk: Buffer) => chunks.push(chunk.toString()))
+
+    const done = Mcp.serve('test-cli', '1.0.0', commands, {
+      input,
+      output,
+      middlewares,
+      vars: z.object({ ran: z.boolean().default(false) }),
+    })
+
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: initParams })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 10))
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'secret', arguments: {} } })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 20))
+    input.end()
+    await done
+
+    const responses = chunks.map((c) => JSON.parse(c.trim()))
+    const callRes = responses.find((r: any) => r.id === 2)
+    expect(callRes.result.content).toEqual([{ type: 'text', text: '{"secret":"data"}' }])
+  })
+
+  test('middleware error blocks tool call', async () => {
+    const commands = new Map<string, any>()
+    commands.set('secret', {
+      description: 'Protected',
+      run: () => ({ secret: true }),
+    })
+    const middlewares = [
+      (c: any) => {
+        c.error({ code: 'FORBIDDEN', message: 'not allowed' })
+      },
+    ]
+    const input = new PassThrough()
+    const output = new PassThrough()
+    const chunks: string[] = []
+    output.on('data', (chunk: Buffer) => chunks.push(chunk.toString()))
+
+    const done = Mcp.serve('test-cli', '1.0.0', commands, {
+      input,
+      output,
+      middlewares,
+    })
+
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: initParams })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 10))
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'secret', arguments: {} } })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 20))
+    input.end()
+    await done
+
+    const responses = chunks.map((c) => JSON.parse(c.trim()))
+    const callRes = responses.find((r: any) => r.id === 2)
+    expect(callRes.result.isError).toBe(true)
+    expect(callRes.result.content[0].text).toBe('not allowed')
+  })
+
+  test('group middleware runs for nested tool calls', async () => {
+    const commands = new Map<string, any>()
+    const groupMiddleware = async (c: any, next: () => Promise<void>) => {
+      c.set('group', 'admin')
+      await next()
+    }
+    commands.set('admin', {
+      _group: true,
+      description: 'Admin commands',
+      middlewares: [groupMiddleware],
+      commands: new Map([
+        [
+          'status',
+          {
+            description: 'Admin status',
+            run: (c: any) => ({ group: c.var.group }),
+          },
+        ],
+      ]),
+    })
+
+    const input = new PassThrough()
+    const output = new PassThrough()
+    const chunks: string[] = []
+    output.on('data', (chunk: Buffer) => chunks.push(chunk.toString()))
+
+    const done = Mcp.serve('test-cli', '1.0.0', commands, {
+      input,
+      output,
+      vars: z.object({ group: z.string().default('none') }),
+    })
+
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: initParams })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 10))
+    input.write(
+      `${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'admin_status', arguments: {} } })}\n`,
+    )
+    await new Promise((r) => setTimeout(r, 20))
+    input.end()
+    await done
+
+    const responses = chunks.map((c) => JSON.parse(c.trim()))
+    const callRes = responses.find((r: any) => r.id === 2)
+    expect(callRes.result.content).toEqual([{ type: 'text', text: '{"group":"admin"}' }])
+  })
+
+  test('env schema is parsed for tool calls', async () => {
+    const commands = new Map<string, any>()
+    commands.set('check-env', {
+      description: 'Check env',
+      env: z.object({ MY_VAR: z.string().default('default-val') }),
+      run: (c: any) => ({ val: c.env.MY_VAR }),
+    })
+
+    const [, res] = await mcpSession(commands, [
+      { id: 1, method: 'initialize', params: initParams },
+      { id: 2, method: 'tools/call', params: { name: 'check-env', arguments: {} } },
+    ])
+    const data = JSON.parse(res.result.content[0].text)
+    expect(data.val).toBe('default-val')
+  })
+
   test('streaming command sends progress notifications', async () => {
     const input = new PassThrough()
     const output = new PassThrough()