incur 0.4.8 → 0.4.10

package/src/lazy-imports.test.ts

@@ -0,0 +1,94 @@
+import { execFile } from 'node:child_process'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+function exec(cmd: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      cmd,
+      args,
+      { cwd: join(import.meta.dirname, '..'), timeout: 30_000 },
+      (error, stdout, stderr) => {
+        if (error) reject(new Error(stderr?.trim() || stdout?.trim() || error.message))
+        else resolve({ stdout, stderr })
+      },
+    )
+  })
+}
+
+let dir: string
+let src: string
+
+describe('lazy imports', () => {
+  beforeAll(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'incur-lazy-'))
+    src = join(dir, 'cli.mts')
+
+    // Records every module loaded during a CLI run, then prints the heavy ones.
+    await writeFile(
+      src,
+      `
+import { registerHooks } from 'node:module'
+
+const loaded: string[] = []
+registerHooks({
+  resolve(specifier, context, next) {
+    const result = next(specifier, context)
+    loaded.push(result.url)
+    return result
+  },
+})
+
+const { Cli, z } = await import('${join(import.meta.dirname, 'index.ts')}')
+
+const cli = Cli.create('lazy-cli', { version: '1.0.0' })
+
+cli.command('ping', {
+  description: 'Health check',
+  options: z.object({ upper: z.boolean().default(false) }),
+  run() {
+    return { pong: true }
+  },
+})
+
+await cli.serve(process.argv.slice(2))
+
+const heavy = loaded.filter(
+  (url) => url.includes('@modelcontextprotocol') || url.includes('node_modules/yaml'),
+)
+console.log(JSON.stringify({ heavy }))
+`,
+    )
+  })
+
+  afterAll(async () => {
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  function parseHeavy(stdout: string): string[] {
+    const line = stdout.trim().split('\n').at(-1)!
+    return (JSON.parse(line) as { heavy: string[] }).heavy
+  }
+
+  test('plain command run does not load yaml or the MCP SDK', async () => {
+    const { stdout } = await exec(process.execPath, ['--import', 'tsx', src, 'ping'])
+    expect(stdout).toContain('pong: true')
+    expect(parseHeavy(stdout)).toEqual([])
+  })
+
+  test('--format yaml loads yaml on demand, but not the MCP SDK', async () => {
+    const { stdout } = await exec(process.execPath, [
+      '--import',
+      'tsx',
+      src,
+      'ping',
+      '--format',
+      'yaml',
+    ])
+    expect(stdout).toContain('pong: true')
+    const heavy = parseHeavy(stdout)
+    expect(heavy.some((url) => url.includes('node_modules/yaml'))).toBe(true)
+    expect(heavy.some((url) => url.includes('@modelcontextprotocol'))).toBe(false)
+  })
+})

package/src/middleware.ts

@@ -10,11 +10,16 @@ type InferVars<vars extends z.ZodObject<any> | undefined> =
 type InferEnv<env extends z.ZodObject<any> | undefined> =
   env extends z.ZodObject<any> ? z.output<env> : {}
 
+/** @internal Infers the output type of a globals schema, or `{}` if undefined. */
+type InferGlobals<globals extends z.ZodObject<any> | undefined> =
+  globals extends z.ZodObject<any> ? z.output<globals> : {}
+
 /** Middleware handler that runs before/after command execution. */
 export type Handler<
   vars extends z.ZodObject<any> | undefined = undefined,
   env extends z.ZodObject<any> | undefined = undefined,
-> = (context: Context<vars, env>, next: () => Promise<void>) => Promise<void> | void
+  globals extends z.ZodObject<any> | undefined = undefined,
+> = (context: Context<vars, env, globals>, next: () => Promise<void>) => Promise<void> | void
 
 /** CTA block for middleware error/ok responses. */
 type CtaBlock = {
@@ -28,6 +33,7 @@ type CtaBlock = {
 export type Context<
   vars extends z.ZodObject<any> | undefined = undefined,
   env extends z.ZodObject<any> | undefined = undefined,
+  globals extends z.ZodObject<any> | undefined = undefined,
 > = {
   /** Whether the consumer is an agent (stdout is not a TTY). */
   agent: boolean
@@ -49,6 +55,8 @@ export type Context<
   format: Formatter.Format
   /** Whether the user explicitly passed `--format` or `--json`. */
   formatExplicit: boolean
+  /** Parsed global options from the CLI-level globals schema. */
+  globals: InferGlobals<globals>
   /** The CLI name. */
   name: string
   /** Set a typed variable for downstream middleware and handlers. */
@@ -59,10 +67,11 @@ export type Context<
   version: string | undefined
 }
 
-/** Creates a strictly typed middleware handler. Pass the vars schema as a generic for typed `c.set()` and `c.var`, and the env schema for typed `c.env`. */
+/** Creates a strictly typed middleware handler. Pass the vars schema as a generic for typed `c.set()` and `c.var`, the env schema for typed `c.env`, and the globals schema for typed `c.globals`. */
 export default function middleware<
   const vars extends z.ZodObject<any> | undefined = undefined,
   const env extends z.ZodObject<any> | undefined = undefined,
->(handler: Handler<vars, env>): Handler<vars, env> {
+  const globals extends z.ZodObject<any> | undefined = undefined,
+>(handler: Handler<vars, env, globals>): Handler<vars, env, globals> {
   return handler
 }