incur 0.2.0 → 0.2.2

package/dist/Cli.js

@@ -1,4 +1,6 @@
+import { estimateTokenCount, sliceByTokens } from 'tokenx';
 import * as Completions from './Completions.js';
+import * as Filter from './Filter.js';
 import { IncurError, ValidationError } from './Errors.js';
 import * as Fetch from './Fetch.js';
 import * as Openapi from './Openapi.js';
@@ -19,6 +21,7 @@ export function create(nameOrDefinition, definition) {
     const commands = new Map();
     const middlewares = [];
     const pending = [];
+    const mcpHandler = createMcpHttpHandler(name, def.version ?? '0.0.0');
     const cli = {
         name,
         description: def.description,
@@ -69,6 +72,16 @@ export function create(nameOrDefinition, definition) {
             });
             return cli;
         },
+        async fetch(req) {
+            if (pending.length > 0)
+                await Promise.all(pending);
+            return fetchImpl(name, commands, req, {
+                mcpHandler,
+                middlewares,
+                rootCommand: rootDef,
+                vars: def.vars,
+            });
+        },
         async serve(argv = process.argv.slice(2), serveOptions = {}) {
             if (pending.length > 0)
                 await Promise.all(pending);
@@ -106,7 +119,7 @@ export function create(nameOrDefinition, definition) {
 async function serveImpl(name, commands, argv, options = {}) {
     const stdout = options.stdout ?? ((s) => process.stdout.write(s));
     const exit = options.exit ?? ((code) => process.exit(code));
-    const { verbose, format: formatFlag, formatExplicit, llms, mcp: mcpFlag, help, version, rest: filtered, } = extractBuiltinFlags(argv);
+    const { verbose, format: formatFlag, formatExplicit, filterOutput, tokenLimit, tokenOffset, tokenCount, llms, mcp: mcpFlag, help, version, schema, rest: filtered, } = extractBuiltinFlags(argv);
     // --mcp: start as MCP stdio server
     if (mcpFlag) {
         await Mcp.serve(name, options.version ?? '0.0.0', commands);
@@ -138,7 +151,7 @@ async function serveImpl(name, commands, argv, options = {}) {
         stdout(s.endsWith('\n') ? s : `${s}\n`);
     }
     // Skills staleness check (skip for built-in commands)
-    if (!llms && !help && !version) {
+    if (!llms && !schema && !help && !version) {
         const isSkillsAdd = filtered[0] === 'skills' || (filtered[0] === name && filtered[1] === 'skills');
         const isMcpAdd = filtered[0] === 'mcp' || (filtered[0] === name && filtered[1] === 'mcp');
         if (!isSkillsAdd && !isMcpAdd) {
@@ -479,6 +492,40 @@ async function serveImpl(name, commands, argv, options = {}) {
         }
         return;
     }
+    // --schema: output JSON Schema for a command's args, env, options, output
+    if (schema) {
+        if ('help' in resolved) {
+            writeln(Help.formatRoot(`${name} ${resolved.path}`, {
+                description: resolved.description,
+                commands: collectHelpCommands(resolved.commands),
+            }));
+            return;
+        }
+        if ('error' in resolved) {
+            const parent = resolved.path ? `${name} ${resolved.path}` : name;
+            writeln(`Error: '${resolved.error}' is not a command for '${parent}'.`);
+            exit(1);
+            return;
+        }
+        if ('fetchGateway' in resolved) {
+            writeln('--schema is not supported for fetch commands.');
+            exit(1);
+            return;
+        }
+        const cmd = resolved.command;
+        const format = formatExplicit ? formatFlag : 'toon';
+        const result = {};
+        if (cmd.args)
+            result.args = Schema.toJsonSchema(cmd.args);
+        if (cmd.env)
+            result.env = Schema.toJsonSchema(cmd.env);
+        if (cmd.options)
+            result.options = Schema.toJsonSchema(cmd.options);
+        if (cmd.output)
+            result.output = Schema.toJsonSchema(cmd.output);
+        writeln(Formatter.format(result, format));
+        return;
+    }
     if ('help' in resolved) {
         writeln(Help.formatRoot(`${name} ${resolved.path}`, {
             description: resolved.description,
@@ -499,28 +546,75 @@ async function serveImpl(name, commands, argv, options = {}) {
     // Resolve outputPolicy: command/group → CLI-level → default ('all')
     const effectiveOutputPolicy = ('outputPolicy' in resolved && resolved.outputPolicy) || options.outputPolicy;
     const renderOutput = !(human && !formatExplicit && effectiveOutputPolicy === 'agent-only');
+    const filterPaths = filterOutput ? Filter.parse(filterOutput) : undefined;
+    function truncate(s) {
+        if (tokenLimit == null && tokenOffset == null)
+            return { text: s, truncated: false };
+        const total = estimateTokenCount(s);
+        const offset = tokenOffset ?? 0;
+        const end = tokenLimit != null ? offset + tokenLimit : total;
+        if (offset === 0 && end >= total)
+            return { text: s, truncated: false };
+        const sliced = sliceByTokens(s, offset, end);
+        const actualEnd = Math.min(end, total);
+        const nextOffset = actualEnd < total ? actualEnd : undefined;
+        return {
+            text: `${sliced}\n[truncated: showing tokens ${offset}–${actualEnd} of ${total}]`,
+            truncated: true,
+            nextOffset,
+        };
+    }
     function write(output) {
+        if (filterPaths && output.ok && output.data != null)
+            output = { ...output, data: Filter.apply(output.data, filterPaths) };
+        if (tokenCount) {
+            const base = output.ok ? output.data : output.error;
+            const formatted = base != null ? Formatter.format(base, format) : '';
+            return writeln(String(estimateTokenCount(formatted)));
+        }
         const cta = output.meta.cta;
         if (human && !verbose) {
-            if (output.ok && output.data != null && renderOutput)
-                writeln(Formatter.format(output.data, format));
+            if (output.ok && output.data != null && renderOutput) {
+                const t = truncate(Formatter.format(output.data, format));
+                writeln(t.text);
+            }
             else if (!output.ok)
                 writeln(formatHumanError(output.error));
             if (cta)
                 writeln(formatHumanCta(cta));
             return;
         }
-        if (verbose)
+        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 t = truncate(dataFormatted);
+                if (t.truncated) {
+                    const envelope = output.ok
+                        ? { ok: true, data: t.text }
+                        : { ok: false, error: t.text };
+                    const meta = { ...output.meta };
+                    if (t.nextOffset != null)
+                        meta.nextOffset = t.nextOffset;
+                    envelope.meta = meta;
+                    return writeln(Formatter.format(envelope, format));
+                }
+            }
             return writeln(Formatter.format(output, format));
+        }
         const base = output.ok ? output.data : output.error;
         const formatted = Formatter.format(base, format);
         if (!cta) {
             if (formatted)
-                writeln(formatted);
+                writeln(truncate(formatted).text);
             return;
         }
         const payload = typeof base === 'object' && base !== null ? { ...base, cta } : { data: base, cta };
-        writeln(Formatter.format(payload, format));
+        writeln(truncate(Formatter.format(payload, format)).text);
     }
     if ('error' in effective) {
         const helpCmd = effective.path ? `${name} ${effective.path} --help` : `${name} --help`;
@@ -573,6 +667,7 @@ async function serveImpl(name, commands, argv, options = {}) {
                     human,
                     renderOutput,
                     verbose,
+                    truncate,
                     write,
                     writeln,
                     exit,
@@ -617,6 +712,8 @@ async function serveImpl(name, commands, argv, options = {}) {
                     command: path,
                     env: cliEnv,
                     error: errorFn,
+                    format,
+                    formatExplicit,
                     name,
                     set(key, value) { varsMap[key] = value; },
                     var: varsMap,
@@ -625,13 +722,14 @@ async function serveImpl(name, commands, argv, options = {}) {
                 const handleMwSentinel = (result) => {
                     if (!isSentinel(result) || result[sentinel] !== 'error')
                         return;
-                    const cta = formatCtaBlock(name, result.cta);
+                    const err = result;
+                    const cta = formatCtaBlock(name, err.cta);
                     write({
                         ok: false,
-                        error: { code: result.code, message: result.message, ...(result.retryable !== undefined ? { retryable: result.retryable } : 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(1);
+                    exit(err.exitCode ?? 1);
                 };
                 const composed = fetchMiddleware.reduceRight((next, mw) => async () => { handleMwSentinel(await mw(mwCtx, next)); }, runFetch);
                 await composed();
@@ -649,7 +747,7 @@ async function serveImpl(name, commands, argv, options = {}) {
                 },
                 meta: { command: path, duration: `${Math.round(performance.now() - start)}ms` },
             });
-            exit(1);
+            exit(error instanceof IncurError ? (error.exitCode ?? 1) : 1);
         }
         return;
     }
@@ -684,10 +782,12 @@ async function serveImpl(name, commands, argv, options = {}) {
             agent: !human,
             args,
             env,
+            error: errorFn,
+            format,
+            formatExplicit,
             name,
-            options: parsedOptions,
             ok: okFn,
-            error: errorFn,
+            options: parsedOptions,
             var: varsMap,
             version: options.version,
         });
@@ -702,6 +802,7 @@ async function serveImpl(name, commands, argv, options = {}) {
                 human,
                 renderOutput,
                 verbose,
+                truncate,
                 write,
                 writeln,
                 exit,
@@ -723,12 +824,13 @@ async function serveImpl(name, commands, argv, options = {}) {
                 });
             }
             else {
+                const err = awaited;
                 write({
                     ok: false,
                     error: {
-                        code: awaited.code,
-                        message: awaited.message,
-                        ...(awaited.retryable !== undefined ? { retryable: awaited.retryable } : undefined),
+                        code: err.code,
+                        message: err.message,
+                        ...(err.retryable !== undefined ? { retryable: err.retryable } : undefined),
                     },
                     meta: {
                         command: path,
@@ -736,7 +838,7 @@ async function serveImpl(name, commands, argv, options = {}) {
                         ...(cta ? { cta } : undefined),
                     },
                 });
-                exit(1);
+                exit(err.exitCode ?? 1);
             }
         }
         else {
@@ -761,6 +863,8 @@ async function serveImpl(name, commands, argv, options = {}) {
                 command: path,
                 env: cliEnv,
                 error: errorFn,
+                format,
+                formatExplicit,
                 name,
                 set(key, value) {
                     varsMap[key] = value;
@@ -771,13 +875,14 @@ async function serveImpl(name, commands, argv, options = {}) {
             const handleMwSentinel = (result) => {
                 if (!isSentinel(result) || result[sentinel] !== 'error')
                     return;
-                const cta = formatCtaBlock(name, result.cta);
+                const err = result;
+                const cta = formatCtaBlock(name, err.cta);
                 write({
                     ok: false,
                     error: {
-                        code: result.code,
-                        message: result.message,
-                        ...(result.retryable !== undefined ? { retryable: result.retryable } : undefined),
+                        code: err.code,
+                        message: err.message,
+                        ...(err.retryable !== undefined ? { retryable: err.retryable } : undefined),
                     },
                     meta: {
                         command: path,
@@ -785,7 +890,7 @@ async function serveImpl(name, commands, argv, options = {}) {
                         ...(cta ? { cta } : undefined),
                     },
                 });
-                exit(1);
+                exit(err.exitCode ?? 1);
             };
             const composed = allMiddleware.reduceRight((next, mw) => async () => {
                 handleMwSentinel(await mw(mwCtx, next));
@@ -820,8 +925,235 @@ async function serveImpl(name, commands, argv, options = {}) {
             return;
         }
         write(errorOutput);
-        exit(1);
+        exit(error instanceof IncurError ? (error.exitCode ?? 1) : 1);
+    }
+}
+/** @internal Creates a lazy MCP HTTP handler scoped to a CLI instance. */
+function createMcpHttpHandler(name, version) {
+    let transport;
+    return async (req, commands) => {
+        if (!transport) {
+            const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+            const { WebStandardStreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
+            const server = new McpServer({ name, version });
+            for (const tool of Mcp.collectTools(commands, [])) {
+                const mergedShape = {
+                    ...tool.command.args?.shape,
+                    ...tool.command.options?.shape,
+                };
+                const hasInput = Object.keys(mergedShape).length > 0;
+                server.registerTool(tool.name, {
+                    ...(tool.description ? { description: tool.description } : undefined),
+                    ...(hasInput ? { inputSchema: mergedShape } : undefined),
+                }, async (...callArgs) => {
+                    const params = hasInput ? callArgs[0] : {};
+                    return Mcp.callTool(tool, params);
+                });
+            }
+            transport = new WebStandardStreamableHTTPServerTransport({
+                sessionIdGenerator: () => crypto.randomUUID(),
+                enableJsonResponse: true,
+            });
+            await server.connect(transport);
+        }
+        return transport.handleRequest(req);
+    };
+}
+/** @internal Handles an HTTP request by resolving a command and returning a JSON Response. */
+async function fetchImpl(name, commands, req, options = {}) {
+    const start = performance.now();
+    const url = new URL(req.url);
+    const segments = url.pathname.split('/').filter(Boolean);
+    // MCP over HTTP: route /mcp to the MCP transport
+    if (segments[0] === 'mcp' && segments.length === 1 && options.mcpHandler)
+        return options.mcpHandler(req, commands);
+    // .well-known/skills/ — Agent Skills Discovery (RFC)
+    if (segments[0] === '.well-known' &&
+        segments[1] === 'skills' &&
+        segments.length >= 3 &&
+        req.method === 'GET') {
+        const groups = new Map();
+        const cmds = collectSkillCommands(commands, [], groups);
+        // GET /.well-known/skills/index.json
+        if (segments[2] === 'index.json' && segments.length === 3) {
+            const files = Skill.split(name, cmds, 1, groups);
+            const skills = files.map((f) => {
+                const descMatch = f.content.match(/^description:\s*(.+)$/m);
+                return {
+                    name: f.dir || name,
+                    description: descMatch?.[1] ?? '',
+                    files: ['SKILL.md'],
+                };
+            });
+            return new Response(JSON.stringify({ skills }), {
+                status: 200,
+                headers: { 'content-type': 'application/json', 'cache-control': 'public, max-age=300' },
+            });
+        }
+        // GET /.well-known/skills/{skill-name}/SKILL.md
+        if (segments.length === 4 && segments[3] === 'SKILL.md') {
+            const skillName = segments[2];
+            const files = Skill.split(name, cmds, 1, groups);
+            const file = files.find((f) => (f.dir || name) === skillName);
+            if (file)
+                return new Response(file.content, {
+                    status: 200,
+                    headers: { 'content-type': 'text/markdown', 'cache-control': 'public, max-age=300' },
+                });
+            return new Response('Not Found', { status: 404 });
+        }
+        return new Response('Not Found', { status: 404 });
+    }
+    // Parse options from search params (GET) or body (non-GET)
+    let inputOptions = {};
+    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());
+        }
+        catch { }
     }
+    function jsonResponse(body, status) {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    // Resolve command from path segments
+    if (segments.length === 0) {
+        // Root path
+        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` } }, 404);
+    }
+    const resolved = resolveCommand(commands, segments);
+    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` } }, 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` } }, 404);
+    if ('fetchGateway' in resolved)
+        return resolved.fetchGateway.fetch(req);
+    const { command, path, rest } = resolved;
+    return executeCommand(path, command, rest, inputOptions, start, options);
+}
+/** @internal Executes a resolved command for the fetch handler and returns a JSON Response. */
+async function executeCommand(path, command, rest, inputOptions, start, options) {
+    function jsonResponse(body, status) {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    const sentinel_ = Symbol.for('incur.sentinel');
+    const varsMap = options.vars ? options.vars.parse({}) : {};
+    let response;
+    const runCommand = async () => {
+        const { args } = Parser.parse(rest, { args: command.args });
+        const parsedOptions = command.options ? command.options.parse(inputOptions) : {};
+        const okFn = (data) => ({ [sentinel_]: 'ok', data });
+        const errorFn = (opts) => ({ [sentinel_]: 'error', ...opts });
+        const result = command.run({
+            agent: true,
+            args,
+            env: {},
+            error: errorFn,
+            format: 'json',
+            formatExplicit: true,
+            name: path,
+            ok: okFn,
+            options: parsedOptions,
+            var: varsMap,
+            version: undefined,
+        });
+        // Streaming path — async generator → NDJSON response
+        if (isAsyncGenerator(result)) {
+            const stream = new ReadableStream({
+                async start(controller) {
+                    const encoder = new TextEncoder();
+                    try {
+                        let returnValue;
+                        while (true) {
+                            const { value, done } = await result.next();
+                            if (done) {
+                                returnValue = value;
+                                break;
+                            }
+                            if (isSentinel(value) && value[sentinel] === 'error') {
+                                const tagged = value;
+                                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'));
+                        }
+                        const meta = { command: path };
+                        if (isSentinel(returnValue) && returnValue[sentinel] === 'error') {
+                            const tagged = returnValue;
+                            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'));
+                        }
+                    }
+                    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.close();
+                },
+            });
+            response = new Response(stream, { status: 200, headers: { 'content-type': 'application/x-ndjson' } });
+            return;
+        }
+        const awaited = await result;
+        const duration = `${Math.round(performance.now() - start)}ms`;
+        if (typeof awaited === 'object' && awaited !== null && sentinel_ in awaited) {
+            const tagged = awaited;
+            if (tagged[sentinel_] === 'error')
+                response = jsonResponse({ ok: false, error: { code: tagged.code, message: tagged.message }, meta: { command: path, duration } }, 500);
+            else
+                response = jsonResponse({ ok: true, data: tagged.data, meta: { command: path, duration } }, 200);
+            return;
+        }
+        response = jsonResponse({ ok: true, data: awaited, meta: { command: path, duration } }, 200);
+    };
+    try {
+        const allMiddleware = options.middlewares ?? [];
+        if (allMiddleware.length > 0) {
+            const errorFn = (opts) => {
+                const duration = `${Math.round(performance.now() - start)}ms`;
+                response = jsonResponse({ ok: false, error: { code: opts.code, message: opts.message }, meta: { command: path, duration } }, 500);
+                return undefined;
+            };
+            const mwCtx = {
+                agent: true,
+                command: path,
+                env: {},
+                error: errorFn,
+                format: 'json',
+                formatExplicit: true,
+                name: path,
+                set(key, value) { varsMap[key] = value; },
+                var: varsMap,
+                version: undefined,
+            };
+            const composed = allMiddleware.reduceRight((next, mw) => async () => { await mw(mwCtx, next); }, runCommand);
+            await composed();
+        }
+        else {
+            await runCommand();
+        }
+    }
+    catch (error) {
+        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 } }, 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 } }, 500);
+    }
+    return response;
 }
 /** @internal Formats a validation error for TTY with usage hint. */
 function formatHumanValidationError(cli, path, command, error, envSource) {
@@ -911,8 +1243,13 @@ function extractBuiltinFlags(argv) {
     let mcp = false;
     let help = false;
     let version = false;
+    let schema = false;
     let format = 'toon';
     let formatExplicit = false;
+    let filterOutput;
+    let tokenLimit;
+    let tokenOffset;
+    let tokenCount = false;
     const rest = [];
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
@@ -926,6 +1263,8 @@ function extractBuiltinFlags(argv) {
             help = true;
         else if (token === '--version')
             version = true;
+        else if (token === '--schema')
+            schema = true;
         else if (token === '--json') {
             format = 'json';
             formatExplicit = true;
@@ -935,10 +1274,24 @@ function extractBuiltinFlags(argv) {
             formatExplicit = true;
             i++;
         }
+        else if (token === '--filter-output' && argv[i + 1]) {
+            filterOutput = argv[i + 1];
+            i++;
+        }
+        else if (token === '--token-limit' && argv[i + 1]) {
+            tokenLimit = Number(argv[i + 1]);
+            i++;
+        }
+        else if (token === '--token-offset' && argv[i + 1]) {
+            tokenOffset = Number(argv[i + 1]);
+            i++;
+        }
+        else if (token === '--token-count')
+            tokenCount = true;
         else
             rest.push(token);
     }
-    return { verbose, format, formatExplicit, llms, mcp, help, version, rest };
+    return { verbose, format, formatExplicit, filterOutput, tokenLimit, tokenOffset, tokenCount, llms, mcp, help, version, schema, rest };
 }
 /** @internal Collects immediate child commands/groups for help output. */
 function collectHelpCommands(commands) {
@@ -1053,14 +1406,14 @@ async function handleStreaming(generator, ctx) {
                             }));
                         else
                             ctx.writeln(formatHumanError({ code: tagged.code, message: tagged.message }));
-                        ctx.exit(1);
+                        ctx.exit(tagged.exitCode ?? 1);
                         return;
                     }
                 }
                 if (useJsonl)
                     ctx.writeln(JSON.stringify({ type: 'chunk', data: value }));
                 else if (ctx.renderOutput)
-                    ctx.writeln(Formatter.format(value, ctx.format));
+                    ctx.writeln(ctx.truncate(Formatter.format(value, ctx.format)).text);
             }
             // Handle return value — error() or ok() sentinel
             if (isSentinel(returnValue) && returnValue[sentinel] === 'error') {
@@ -1077,7 +1430,7 @@ async function handleStreaming(generator, ctx) {
                     }));
                 else
                     ctx.writeln(formatHumanError({ code: err.code, message: err.message }));
-                ctx.exit(1);
+                ctx.exit(err.exitCode ?? 1);
                 return;
             }
             const cta = isSentinel(returnValue) && returnValue[sentinel] === 'ok'
@@ -1111,7 +1464,7 @@ async function handleStreaming(generator, ctx) {
                     code: 'UNKNOWN',
                     message: error instanceof Error ? error.message : String(error),
                 }));
-            ctx.exit(1);
+            ctx.exit(error instanceof IncurError ? (error.exitCode ?? 1) : 1);
         }
     }
     else {
@@ -1140,7 +1493,7 @@ async function handleStreaming(generator, ctx) {
                                 duration: `${Math.round(performance.now() - ctx.start)}ms`,
                             },
                         });
-                        ctx.exit(1);
+                        ctx.exit(tagged.exitCode ?? 1);
                         return;
                     }
                 }
@@ -1160,7 +1513,7 @@ async function handleStreaming(generator, ctx) {
                         duration: `${Math.round(performance.now() - ctx.start)}ms`,
                     },
                 });
-                ctx.exit(1);
+                ctx.exit(err.exitCode ?? 1);
                 return;
             }
             const cta = isSentinel(returnValue) && returnValue[sentinel] === 'ok'
@@ -1188,7 +1541,7 @@ async function handleStreaming(generator, ctx) {
                     duration: `${Math.round(performance.now() - ctx.start)}ms`,
                 },
             });
-            ctx.exit(1);
+            ctx.exit(error instanceof IncurError ? (error.exitCode ?? 1) : 1);
         }
     }
 }