incur 0.3.2 → 0.4.0

package/src/Cli.ts

@@ -1,18 +1,18 @@
+import { estimateTokenCount, sliceByTokens } from 'tokenx'
 import type { z } from 'zod'
 
-import { estimateTokenCount, sliceByTokens } from 'tokenx'
 import * as Completions from './Completions.js'
-import * as Filter from './Filter.js'
 import type { FieldError } from './Errors.js'
 import { IncurError, ValidationError } from './Errors.js'
 import * as Fetch from './Fetch.js'
-import * as Openapi from './Openapi.js'
+import * as Filter from './Filter.js'
 import * as Formatter from './Formatter.js'
 import * as Help from './Help.js'
 import { detectRunner } from './internal/pm.js'
 import type { OneOf } from './internal/types.js'
 import * as Mcp from './Mcp.js'
 import type { Context as MiddlewareContext, Handler as MiddlewareHandler } from './middleware.js'
+import * as Openapi from './Openapi.js'
 export type { MiddlewareHandler }
 import * as Parser from './Parser.js'
 import type { Register } from './Register.js'
@@ -26,6 +26,7 @@ export type Cli<
   commands extends CommandsMap = {},
   vars extends z.ZodObject<any> | undefined = undefined,
   env extends z.ZodObject<any> | undefined = undefined,
+  opts extends z.ZodObject<any> | undefined = undefined,
 > = {
   /** Registers a root command or mounts a sub-CLI as a command group. */
   command: {
@@ -42,29 +43,42 @@ export type Cli<
     ): Cli<
       commands & { [key in name]: { args: InferOutput<args>; options: InferOutput<options> } },
       vars,
-      env
+      env,
+      opts
     >
     /** Mounts a sub-CLI as a command group. */
     <const name extends string, const sub extends CommandsMap>(
-      cli: Cli<sub, any, any> & { name: name },
-    ): Cli<commands & { [key in keyof sub & string as `${name} ${key}`]: sub[key] }, vars, env>
+      cli: Cli<sub, any, any, any> & { name: name },
+    ): Cli<
+      commands & { [key in keyof sub & string as `${name} ${key}`]: sub[key] },
+      vars,
+      env,
+      opts
+    >
     /** Mounts a root CLI as a single command. */
     <
       const name extends string,
       const args extends z.ZodObject<any> | undefined,
-      const opts extends z.ZodObject<any> | undefined,
+      const cmdOpts extends z.ZodObject<any> | undefined,
     >(
-      cli: Root<args, opts> & { name: name },
+      cli: Root<args, cmdOpts> & { name: name },
     ): Cli<
-      commands & { [key in name]: { args: InferOutput<args>; options: InferOutput<opts> } },
+      commands & { [key in name]: { args: InferOutput<args>; options: InferOutput<cmdOpts> } },
       vars,
-      env
+      env,
+      opts
     >
     /** Mounts a fetch handler as a command, optionally with OpenAPI spec for typed subcommands. */
     <const name extends string>(
       name: name,
-      definition: { basePath?: string | undefined; description?: string | undefined; fetch: FetchHandler; openapi?: Openapi.OpenAPISpec | undefined; outputPolicy?: OutputPolicy | undefined },
-    ): Cli<commands, vars, env>
+      definition: {
+        basePath?: string | undefined
+        description?: string | undefined
+        fetch: FetchHandler
+        openapi?: Openapi.OpenAPISpec | undefined
+        outputPolicy?: OutputPolicy | undefined
+      },
+    ): Cli<commands, vars, env, opts>
   }
   /** A short description of the CLI. */
   description?: string | undefined
@@ -76,8 +90,10 @@ export type Cli<
   fetch(req: Request): Promise<Response>
   /** Parses argv, runs the matched command, and writes the output envelope to stdout. */
   serve(argv?: string[], options?: serve.Options): Promise<void>
+  /** The options schema, if declared. Use `typeof cli.options` with `middleware<vars, env, options>()` for typed middleware. */
+  options: opts
   /** Registers middleware that runs around every command. */
-  use(handler: MiddlewareHandler<vars, env>): Cli<commands, vars, env>
+  use(handler: MiddlewareHandler<vars, env, opts>): Cli<commands, vars, env, opts>
   /** The vars schema, if declared. Use `typeof cli.vars` with `middleware<vars, env>()` for typed middleware. */
   vars: vars
 }
@@ -145,7 +161,12 @@ export function create<
 >(
   name: string,
   definition: create.Options<args, env, opts, output, vars> & { run: Function },
-): Cli<{ [key in typeof name]: { args: InferOutput<args>; options: InferOutput<opts> } }, vars, env>
+): Cli<
+  { [key in typeof name]: { args: InferOutput<args>; options: InferOutput<opts> } },
+  vars,
+  env,
+  opts
+>
 /** Creates a router CLI that registers subcommands. */
 export function create<
   const args extends z.ZodObject<any> | undefined = undefined,
@@ -153,7 +174,10 @@ export function create<
   const opts extends z.ZodObject<any> | undefined = undefined,
   const output extends z.ZodType | undefined = undefined,
   const vars extends z.ZodObject<any> | undefined = undefined,
->(name: string, definition?: create.Options<args, env, opts, output, vars>): Cli<{}, vars, env>
+>(
+  name: string,
+  definition?: create.Options<args, env, opts, output, vars>,
+): Cli<{}, vars, env, opts>
 /** Creates a CLI with a root handler from a single options object. Can still register subcommands. */
 export function create<
   const args extends z.ZodObject<any> | undefined = undefined,
@@ -168,7 +192,8 @@ export function create<
     [key in (typeof definition)['name']]: { args: InferOutput<args>; options: InferOutput<opts> }
   },
   vars,
-  env
+  env,
+  opts
 >
 /** Creates a router CLI from a single options object (e.g. package.json). */
 export function create<
@@ -177,7 +202,9 @@ export function create<
   const opts extends z.ZodObject<any> | undefined = undefined,
   const output extends z.ZodType | undefined = undefined,
   const vars extends z.ZodObject<any> | undefined = undefined,
->(definition: create.Options<args, env, opts, output, vars> & { name: string }): Cli<{}, vars, env>
+>(
+  definition: create.Options<args, env, opts, output, vars> & { name: string },
+): Cli<{}, vars, env, opts>
 export function create(
   nameOrDefinition: string | (any & { name: string }),
   definition?: any,
@@ -196,6 +223,7 @@ export function create(
     name,
     description: def.description,
     env: def.env,
+    options: def.options,
     vars: def.vars,
 
     command(nameOrCli: any, def?: any): any {
@@ -204,14 +232,16 @@ export function create(
           // OpenAPI + fetch → generate typed command group (async, resolved before serve)
           if (def.openapi) {
             pending.push(
-              Openapi.generateCommands(def.openapi, def.fetch, { basePath: def.basePath }).then((generated) => {
-                commands.set(nameOrCli, {
-                  _group: true,
-                  description: def.description,
-                  commands: generated as Map<string, CommandEntry>,
-                  ...(def.outputPolicy ? { outputPolicy: def.outputPolicy } : undefined),
-                } as InternalGroup)
-              }),
+              Openapi.generateCommands(def.openapi, def.fetch, { basePath: def.basePath }).then(
+                (generated) => {
+                  commands.set(nameOrCli, {
+                    _group: true,
+                    description: def.description,
+                    commands: generated as Map<string, CommandEntry>,
+                    ...(def.outputPolicy ? { outputPolicy: def.outputPolicy } : undefined),
+                  } as InternalGroup)
+                },
+              ),
             )
             return cli
           }
@@ -266,6 +296,7 @@ export function create(
         format: def.format,
         mcp: def.mcp,
         middlewares,
+        optionsSchema: def.options,
         outputPolicy: def.outputPolicy,
         rootCommand: rootDef,
         rootFetch,
@@ -786,7 +817,16 @@ async function serveImpl(
     filtered.length === 0 && options.rootCommand
       ? { command: options.rootCommand, path: name, rest: [] as string[] }
       : filtered.length === 0 && options.rootFetch
-        ? { fetchGateway: { _fetch: true as const, fetch: options.rootFetch, description: options.description }, middlewares: [] as MiddlewareHandler[], path: name, rest: [] as string[] }
+        ? {
+            fetchGateway: {
+              _fetch: true as const,
+              fetch: options.rootFetch,
+              description: options.description,
+            },
+            middlewares: [] as MiddlewareHandler[],
+            path: name,
+            rest: [] as string[],
+          }
         : resolveCommand(commands, filtered)
 
   // --help on a fetch gateway → show fetch-specific help
@@ -909,6 +949,14 @@ async function serveImpl(
 
   const start = performance.now()
 
+  // Parse root CLI-level options (available to middleware via c.options)
+  const rootOptions = options.optionsSchema
+    ? Parser.parse(filtered, {
+        alias: options.rootCommand?.alias as Record<string, string> | undefined,
+        options: options.optionsSchema,
+      }).options
+    : {}
+
   // Resolve effective format: explicit --format/--json → command default → CLI default → toon
   const resolvedFormat = 'command' in resolved && (resolved as any).command.format
   const format = formatExplicit ? formatFlag : resolvedFormat || options.format || 'toon'
@@ -916,7 +964,16 @@ async function serveImpl(
   // Fall back to root fetch when no subcommand matches
   const effective =
     'error' in resolved && options.rootFetch && !resolved.path
-      ? { fetchGateway: { _fetch: true as const, fetch: options.rootFetch, description: options.description }, middlewares: [] as MiddlewareHandler[], path: name, rest: filtered }
+      ? {
+          fetchGateway: {
+            _fetch: true as const,
+            fetch: options.rootFetch,
+            description: options.description,
+          },
+          middlewares: [] as MiddlewareHandler[],
+          path: name,
+          rest: filtered,
+        }
       : 'error' in resolved && options.rootCommand && !resolved.path
         ? { command: options.rootCommand, path: name, rest: filtered }
         : resolved
@@ -928,7 +985,11 @@ async function serveImpl(
 
   const filterPaths = filterOutput ? Filter.parse(filterOutput) : undefined
 
-  function truncate(s: string): { text: string; truncated: boolean; nextOffset?: number | undefined } {
+  function truncate(s: string): {
+    text: string
+    truncated: boolean
+    nextOffset?: number | undefined
+  } {
     if (tokenLimit == null && tokenOffset == null) return { text: s, truncated: false }
     const total = estimateTokenCount(s)
     const offset = tokenOffset ?? 0
@@ -964,11 +1025,12 @@ async function serveImpl(
     if (verbose) {
       if (tokenLimit != null || tokenOffset != null) {
         // Truncate data separately so meta (including nextOffset) is always visible
-        const dataFormatted = output.ok && output.data != null
-          ? Formatter.format(output.data, format)
-          : !output.ok
-            ? Formatter.format(output.error, format)
-            : ''
+        const dataFormatted =
+          output.ok && output.data != null
+            ? Formatter.format(output.data, format)
+            : !output.ok
+              ? Formatter.format(output.error, format)
+              : ''
         const t = truncate(dataFormatted)
         if (t.truncated) {
           const envelope: Record<string, unknown> = output.ok
@@ -1070,9 +1132,12 @@ async function serveImpl(
           ok: false,
           error: {
             code: `HTTP_${output.status}`,
-            message: typeof output.data === 'object' && output.data !== null && 'message' in output.data
-              ? String((output.data as any).message)
-              : typeof output.data === 'string' ? output.data : `HTTP ${output.status}`,
+            message:
+              typeof output.data === 'object' && output.data !== null && 'message' in output.data
+                ? String((output.data as any).message)
+                : typeof output.data === 'string'
+                  ? output.data
+                  : `HTTP ${output.status}`,
           },
           meta: {
             command: path,
@@ -1084,11 +1149,18 @@ async function serveImpl(
     }
 
     try {
-      const cliEnv = options.envSchema ? Parser.parseEnv(options.envSchema, options.env ?? process.env) : {}
+      const cliEnv = options.envSchema
+        ? Parser.parseEnv(options.envSchema, options.env ?? process.env)
+        : {}
       if (fetchMiddleware.length > 0) {
         const varsMap: Record<string, unknown> = options.vars ? options.vars.parse({}) : {}
-        const errorFn = (opts: { code: string; exitCode?: number | undefined; message: string; retryable?: boolean | undefined; cta?: CtaBlock | undefined }): never =>
-          ({ [sentinel]: 'error', ...opts }) as never
+        const errorFn = (opts: {
+          code: string
+          exitCode?: number | undefined
+          message: string
+          retryable?: boolean | undefined
+          cta?: CtaBlock | undefined
+        }): never => ({ [sentinel]: 'error', ...opts }) as never
         const mwCtx: MiddlewareContext = {
           agent: !human,
           command: path,
@@ -1097,7 +1169,10 @@ async function serveImpl(
           format,
           formatExplicit,
           name,
-          set(key: string, value: unknown) { varsMap[key] = value },
+          options: rootOptions,
+          set(key: string, value: unknown) {
+            varsMap[key] = value
+          },
           var: varsMap,
           version: options.version,
         }
@@ -1107,13 +1182,23 @@ async function serveImpl(
           const cta = formatCtaBlock(name, err.cta)
           write({
             ok: false,
-            error: { code: err.code, message: err.message, ...(err.retryable !== undefined ? { retryable: err.retryable } : undefined) },
-            meta: { command: path, duration: `${Math.round(performance.now() - start)}ms`, ...(cta ? { cta } : undefined) },
+            error: {
+              code: err.code,
+              message: err.message,
+              ...(err.retryable !== undefined ? { retryable: err.retryable } : undefined),
+            },
+            meta: {
+              command: path,
+              duration: `${Math.round(performance.now() - start)}ms`,
+              ...(cta ? { cta } : undefined),
+            },
           })
           exit(err.exitCode ?? 1)
         }
         const composed = fetchMiddleware.reduceRight(
-          (next: () => Promise<void>, mw) => async () => { handleMwSentinel(await mw(mwCtx, next)) },
+          (next: () => Promise<void>, mw) => async () => {
+            handleMwSentinel(await mw(mwCtx, next))
+          },
           runFetch,
         )
         await composed()
@@ -1275,6 +1360,7 @@ async function serveImpl(
         format,
         formatExplicit,
         name,
+        options: rootOptions,
         set(key: string, value: unknown) {
           varsMap[key] = value
         },
@@ -1344,7 +1430,9 @@ async function serveImpl(
 /** @internal Options for fetchImpl. */
 declare namespace fetchImpl {
   type Options = {
-    mcpHandler?: ((req: Request, commands: Map<string, CommandEntry>) => Promise<Response>) | undefined
+    mcpHandler?:
+      | ((req: Request, commands: Map<string, CommandEntry>) => Promise<Response>)
+      | undefined
     middlewares?: MiddlewareHandler[] | undefined
     rootCommand?: CommandDefinition<any, any, any> | undefined
     vars?: z.ZodObject<any> | undefined
@@ -1358,9 +1446,8 @@ function createMcpHttpHandler(name: string, version: string) {
   return async (req: Request, commands: Map<string, CommandEntry>): Promise<Response> => {
     if (!transport) {
       const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js')
-      const { WebStandardStreamableHTTPServerTransport } = await import(
-        '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js'
-      )
+      const { WebStandardStreamableHTTPServerTransport } =
+        await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js')
 
       const server = new McpServer({ name, version })
 
@@ -1455,12 +1542,12 @@ async function fetchImpl(
 
   // Parse options from search params (GET) or body (non-GET)
   let inputOptions: Record<string, unknown> = {}
-  if (req.method === 'GET')
-    for (const [key, value] of url.searchParams) inputOptions[key] = value
+  if (req.method === 'GET') for (const [key, value] of url.searchParams) inputOptions[key] = value
   else {
     try {
       const contentType = req.headers.get('content-type') ?? ''
-      if (contentType.includes('application/json')) inputOptions = (await req.json()) as Record<string, unknown>
+      if (contentType.includes('application/json'))
+        inputOptions = (await req.json()) as Record<string, unknown>
     } catch {}
   }
 
@@ -1477,7 +1564,11 @@ async function fetchImpl(
     if (options.rootCommand)
       return executeCommand(name, options.rootCommand, [], inputOptions, start, options)
     return jsonResponse(
-      { ok: false, error: { code: 'COMMAND_NOT_FOUND', message: 'No root command defined.' }, meta: { command: '/', duration: `${Math.round(performance.now() - start)}ms` } },
+      {
+        ok: false,
+        error: { code: 'COMMAND_NOT_FOUND', message: 'No root command defined.' },
+        meta: { command: '/', duration: `${Math.round(performance.now() - start)}ms` },
+      },
       404,
     )
   }
@@ -1486,18 +1577,31 @@ async function fetchImpl(
 
   if ('error' in resolved)
     return jsonResponse(
-      { ok: false, error: { code: 'COMMAND_NOT_FOUND', message: `'${resolved.error}' is not a command for '${resolved.path ? `${name} ${resolved.path}` : name}'.` }, meta: { command: resolved.error, duration: `${Math.round(performance.now() - start)}ms` } },
+      {
+        ok: false,
+        error: {
+          code: 'COMMAND_NOT_FOUND',
+          message: `'${resolved.error}' is not a command for '${resolved.path ? `${name} ${resolved.path}` : name}'.`,
+        },
+        meta: { command: resolved.error, duration: `${Math.round(performance.now() - start)}ms` },
+      },
       404,
     )
 
   if ('help' in resolved)
     return jsonResponse(
-      { ok: false, error: { code: 'COMMAND_NOT_FOUND', message: `'${resolved.path}' is a command group. Specify a subcommand.` }, meta: { command: resolved.path, duration: `${Math.round(performance.now() - start)}ms` } },
+      {
+        ok: false,
+        error: {
+          code: 'COMMAND_NOT_FOUND',
+          message: `'${resolved.path}' is a command group. Specify a subcommand.`,
+        },
+        meta: { command: resolved.path, duration: `${Math.round(performance.now() - start)}ms` },
+      },
       404,
     )
 
-  if ('fetchGateway' in resolved)
-    return resolved.fetchGateway.fetch(req)
+  if ('fetchGateway' in resolved) return resolved.fetchGateway.fetch(req)
 
   const { command, path, rest } = resolved
   return executeCommand(path, command, rest, inputOptions, start, options)
@@ -1528,8 +1632,11 @@ async function executeCommand(
     const parsedOptions = command.options ? command.options.parse(inputOptions) : {}
 
     const okFn = (data: unknown): never => ({ [sentinel_]: 'ok', data }) as never
-    const errorFn = (opts: { code: string; message: string; exitCode?: number | undefined }): never =>
-      ({ [sentinel_]: 'error', ...opts }) as never
+    const errorFn = (opts: {
+      code: string
+      message: string
+      exitCode?: number | undefined
+    }): never => ({ [sentinel_]: 'error', ...opts }) as never
 
     const result = command.run({
       agent: true,
@@ -1560,26 +1667,60 @@ async function executeCommand(
               }
               if (isSentinel(value) && (value as any)[sentinel] === 'error') {
                 const tagged = value as any
-                controller.enqueue(encoder.encode(JSON.stringify({ type: 'error', ok: false, error: { code: tagged.code, message: tagged.message } }) + '\n'))
+                controller.enqueue(
+                  encoder.encode(
+                    JSON.stringify({
+                      type: 'error',
+                      ok: false,
+                      error: { code: tagged.code, message: tagged.message },
+                    }) + '\n',
+                  ),
+                )
                 controller.close()
                 return
               }
-              controller.enqueue(encoder.encode(JSON.stringify({ type: 'chunk', data: value }) + '\n'))
+              controller.enqueue(
+                encoder.encode(JSON.stringify({ type: 'chunk', data: value }) + '\n'),
+              )
             }
             const meta: Record<string, unknown> = { command: path }
             if (isSentinel(returnValue) && (returnValue as any)[sentinel] === 'error') {
               const tagged = returnValue as any
-              controller.enqueue(encoder.encode(JSON.stringify({ type: 'error', ok: false, error: { code: tagged.code, message: tagged.message } }) + '\n'))
+              controller.enqueue(
+                encoder.encode(
+                  JSON.stringify({
+                    type: 'error',
+                    ok: false,
+                    error: { code: tagged.code, message: tagged.message },
+                  }) + '\n',
+                ),
+              )
             } else {
-              controller.enqueue(encoder.encode(JSON.stringify({ type: 'done', ok: true, meta }) + '\n'))
+              controller.enqueue(
+                encoder.encode(JSON.stringify({ type: 'done', ok: true, meta }) + '\n'),
+              )
             }
           } catch (error) {
-            controller.enqueue(encoder.encode(JSON.stringify({ type: 'error', ok: false, error: { code: 'UNKNOWN', message: error instanceof Error ? error.message : String(error) } }) + '\n'))
+            controller.enqueue(
+              encoder.encode(
+                JSON.stringify({
+                  type: 'error',
+                  ok: false,
+                  error: {
+                    code: 'UNKNOWN',
+                    message: error instanceof Error ? error.message : String(error),
+                  },
+                }) + '\n',
+              ),
+            )
           }
           controller.close()
         },
       })
-      response = new Response(stream, { status: 200, headers: { 'content-type': 'application/x-ndjson' } })
+      response = new Response(stream, {
+        status: 200,
+        headers: { 'content-type': 'application/x-ndjson' },
+      })
       return
     }
 
@@ -1590,7 +1731,11 @@ async function executeCommand(
       const tagged = awaited as any
       if (tagged[sentinel_] === 'error')
         response = jsonResponse(
-          { ok: false, error: { code: tagged.code, message: tagged.message }, meta: { command: path, duration } },
+          {
+            ok: false,
+            error: { code: tagged.code, message: tagged.message },
+            meta: { command: path, duration },
+          },
           500,
         )
       else
@@ -1601,19 +1746,24 @@ async function executeCommand(
       return
     }
 
-    response = jsonResponse(
-      { ok: true, data: awaited, meta: { command: path, duration } },
-      200,
-    )
+    response = jsonResponse({ ok: true, data: awaited, meta: { command: path, duration } }, 200)
   }
 
   try {
     const allMiddleware = options.middlewares ?? []
     if (allMiddleware.length > 0) {
-      const errorFn = (opts: { code: string; message: string; exitCode?: number | undefined }): never => {
+      const errorFn = (opts: {
+        code: string
+        message: string
+        exitCode?: number | undefined
+      }): never => {
         const duration = `${Math.round(performance.now() - start)}ms`
         response = jsonResponse(
-          { ok: false, error: { code: opts.code, message: opts.message }, meta: { command: path, duration } },
+          {
+            ok: false,
+            error: { code: opts.code, message: opts.message },
+            meta: { command: path, duration },
+          },
           500,
         )
         return undefined as never
@@ -1626,12 +1776,17 @@ async function executeCommand(
         format: 'json',
         formatExplicit: true,
         name: path,
-        set(key: string, value: unknown) { varsMap[key] = value },
+        options: {},
+        set(key: string, value: unknown) {
+          varsMap[key] = value
+        },
         var: varsMap,
         version: undefined,
       }
       const composed = allMiddleware.reduceRight(
-        (next: () => Promise<void>, mw) => async () => { await mw(mwCtx, next) },
+        (next: () => Promise<void>, mw) => async () => {
+          await mw(mwCtx, next)
+        },
         runCommand,
       )
       await composed()
@@ -1642,11 +1797,22 @@ async function executeCommand(
     const duration = `${Math.round(performance.now() - start)}ms`
     if (error instanceof ValidationError)
       return jsonResponse(
-        { ok: false, error: { code: 'VALIDATION_ERROR', message: error.message }, meta: { command: path, duration } },
+        {
+          ok: false,
+          error: { code: 'VALIDATION_ERROR', message: error.message },
+          meta: { command: path, duration },
+        },
         400,
       )
     return jsonResponse(
-      { ok: false, error: { code: error instanceof IncurError ? error.code : 'UNKNOWN', message: error instanceof Error ? error.message : String(error) }, meta: { command: path, duration } },
+      {
+        ok: false,
+        error: {
+          code: error instanceof IncurError ? error.code : 'UNKNOWN',
+          message: error instanceof Error ? error.message : String(error),
+        },
+        meta: { command: path, duration },
+      },
       500,
     )
   }
@@ -1785,6 +1951,8 @@ declare namespace serveImpl {
     format?: Formatter.Format | undefined
     /** Middleware handlers registered on the root CLI. */
     middlewares?: MiddlewareHandler[] | undefined
+    /** CLI-level options schema. Parsed before middleware runs. */
+    optionsSchema?: z.ZodObject<any> | undefined
     /** CLI-level default output policy. */
     outputPolicy?: OutputPolicy | undefined
     mcp?:
@@ -1857,7 +2025,22 @@ function extractBuiltinFlags(argv: string[]) {
     else rest.push(token)
   }
 
-  return { verbose, format, formatExplicit, filterOutput, tokenLimit, tokenOffset, tokenCount, llms, llmsFull, mcp, help, version, schema, rest }
+  return {
+    verbose,
+    format,
+    formatExplicit,
+    filterOutput,
+    tokenLimit,
+    tokenOffset,
+    tokenCount,
+    llms,
+    llmsFull,
+    mcp,
+    help,
+    version,
+    schema,
+    rest,
+  }
 }
 
 /** @internal Collects immediate child commands/groups for help output. */
@@ -2073,7 +2256,8 @@ async function handleStreaming(
           }
         }
         if (useJsonl) ctx.writeln(JSON.stringify({ type: 'chunk', data: value }))
-        else if (ctx.renderOutput) ctx.writeln(ctx.truncate(Formatter.format(value, ctx.format)).text)
+        else if (ctx.renderOutput)
+          ctx.writeln(ctx.truncate(Formatter.format(value, ctx.format)).text)
       }
 
       // Handle return value — error() or ok() sentinel

package/src/Fetch.test.ts

@@ -66,13 +66,7 @@ describe('parseArgv', () => {
   })
 
   test('multiple headers', () => {
-    const input = Fetch.parseArgv([
-      'users',
-      '-H',
-      'X-A: 1',
-      '-H',
-      'X-B: 2',
-    ])
+    const input = Fetch.parseArgv(['users', '-H', 'X-A: 1', '-H', 'X-B: 2'])
     expect(input.headers.get('X-A')).toBe('1')
     expect(input.headers.get('X-B')).toBe('2')
   })
@@ -123,16 +117,12 @@ describe('buildRequest', () => {
   })
 
   test('builds POST request with body', () => {
-    const req = Fetch.buildRequest(
-      Fetch.parseArgv(['users', '-X', 'POST', '-d', '{"name":"Bob"}']),
-    )
+    const req = Fetch.buildRequest(Fetch.parseArgv(['users', '-X', 'POST', '-d', '{"name":"Bob"}']))
     expect(req.method).toBe('POST')
   })
 
   test('builds request with headers', () => {
-    const req = Fetch.buildRequest(
-      Fetch.parseArgv(['users', '-H', 'X-Api-Key: secret']),
-    )
+    const req = Fetch.buildRequest(Fetch.parseArgv(['users', '-H', 'X-Api-Key: secret']))
     expect(req.headers.get('X-Api-Key')).toBe('secret')
   })
 })

package/src/Fetch.ts

@@ -102,8 +102,7 @@ export function buildRequest(input: FetchInput): Request {
 
   if (input.body !== undefined) {
     init.body = input.body
-    if (!input.headers.has('content-type'))
-      input.headers.set('content-type', 'application/json')
+    if (!input.headers.has('content-type')) input.headers.set('content-type', 'application/json')
   }
 
   return new Request(url.toString(), init)