@pungoyal/kite-cli 0.1.0

package/dist/output/format.js

@@ -0,0 +1,162 @@
+/**
+ * Number, currency and date formatting.
+ *
+ * Everything is rendered in the Indian locale and IST, because that is the only
+ * frame of reference Kite operates in. Rupee amounts use the Indian digit
+ * grouping (lakh/crore), which `en-IN` gives us for free.
+ */
+const INR = new Intl.NumberFormat('en-IN', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+const INR_COMPACT = new Intl.NumberFormat('en-IN', {
+    maximumFractionDigits: 0,
+});
+const QTY = new Intl.NumberFormat('en-IN', { maximumFractionDigits: 0 });
+/** A rupee amount, e.g. "12,34,567.89". No symbol — callers add it. */
+export function money(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    return INR.format(value);
+}
+/** A rupee amount with the symbol, e.g. "₹12,34,567.89". */
+export function rupees(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    return `₹${INR.format(value)}`;
+}
+/** A signed rupee amount, e.g. "+₹1,200.00" / "-₹340.50". */
+export function signedRupees(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    const sign = value > 0 ? '+' : value < 0 ? '-' : '';
+    return `${sign}₹${INR.format(Math.abs(value))}`;
+}
+/** Large rupee amounts abbreviated as L / Cr, the conventional Indian units. */
+export function compactRupees(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    const abs = Math.abs(value);
+    const sign = value < 0 ? '-' : '';
+    if (abs >= 10_000_000)
+        return `${sign}₹${(abs / 10_000_000).toFixed(2)}Cr`;
+    if (abs >= 100_000)
+        return `${sign}₹${(abs / 100_000).toFixed(2)}L`;
+    return `${sign}₹${INR_COMPACT.format(abs)}`;
+}
+export function percent(value, digits = 2) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    const sign = value > 0 ? '+' : '';
+    return `${sign}${value.toFixed(digits)}%`;
+}
+export function quantity(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    return QTY.format(value);
+}
+/** Compact volume, e.g. "1.2M". */
+export function compactNumber(value) {
+    if (value === undefined || value === null || !Number.isFinite(value))
+        return '—';
+    const abs = Math.abs(value);
+    const sign = value < 0 ? '-' : '';
+    if (abs >= 1_000_000_000)
+        return `${sign}${(abs / 1_000_000_000).toFixed(1)}B`;
+    if (abs >= 1_000_000)
+        return `${sign}${(abs / 1_000_000).toFixed(1)}M`;
+    if (abs >= 1_000)
+        return `${sign}${(abs / 1_000).toFixed(1)}K`;
+    return `${sign}${abs}`;
+}
+const IST_DATETIME = new Intl.DateTimeFormat('en-IN', {
+    timeZone: 'Asia/Kolkata',
+    year: 'numeric',
+    month: 'short',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+});
+const IST_TIME = new Intl.DateTimeFormat('en-IN', {
+    timeZone: 'Asia/Kolkata',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+});
+const IST_DATE = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Asia/Kolkata',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+});
+export function dateTime(value) {
+    const date = toDate(value);
+    return date ? IST_DATETIME.format(date) : '—';
+}
+export function timeOnly(value) {
+    const date = toDate(value);
+    return date ? IST_TIME.format(date) : '—';
+}
+export function dateOnly(value) {
+    const date = toDate(value);
+    return date ? IST_DATE.format(date) : '—';
+}
+function toDate(value) {
+    if (!value)
+        return null;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? null : value;
+    // Kite returns "YYYY-MM-DD HH:MM:SS" without a zone in most responses
+    // (implicitly IST), but ISO-8601 with +0530 for historical candles.
+    const normalised = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value) ? `${value.replace(' ', 'T')}+05:30` : value;
+    const parsed = new Date(normalised);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/**
+ * Parse a user-supplied date for historical queries.
+ *
+ * Accepts YYYY-MM-DD, "YYYY-MM-DD HH:MM:SS", and relative offsets like "7d",
+ * "3m", "1y" meaning "N units ago".
+ */
+export function parseUserDate(value, now = new Date()) {
+    const trimmed = value.trim();
+    const relative = /^(\d+)\s*([dwmy])$/i.exec(trimmed);
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unit = relative[2].toLowerCase();
+        const result = new Date(now);
+        if (unit === 'd')
+            result.setDate(result.getDate() - amount);
+        else if (unit === 'w')
+            result.setDate(result.getDate() - amount * 7);
+        else if (unit === 'm')
+            result.setMonth(result.getMonth() - amount);
+        else
+            result.setFullYear(result.getFullYear() - amount);
+        return result;
+    }
+    if (trimmed.toLowerCase() === 'today') {
+        return now;
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        // Interpret a bare date as IST midnight, not UTC.
+        const parsed = new Date(`${trimmed}T00:00:00+05:30`);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2})?$/.test(trimmed)) {
+        const withSeconds = trimmed.length === 16 ? `${trimmed}:00` : trimmed;
+        const parsed = new Date(`${withSeconds.replace(' ', 'T')}+05:30`);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    const fallback = new Date(trimmed);
+    return Number.isNaN(fallback.getTime()) ? null : fallback;
+}
+/** Truncate to a display width, appending an ellipsis. */
+export function truncate(value, max) {
+    if (max <= 1)
+        return value.slice(0, Math.max(0, max));
+    return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}

package/dist/output/io.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Output context.
+ *
+ * The contract, per https://clig.dev:
+ *   - data goes to stdout, everything else (logs, progress, errors) to stderr
+ *   - `--json` forces machine mode even on a TTY, because users eyeball output
+ *     before piping it
+ *   - stdout.isTTY and stderr.isTTY are checked INDEPENDENTLY; they differ
+ *     constantly (`kite quote > file` leaves stderr a TTY)
+ */
+export interface IoStreams {
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+}
+export interface IoOptions {
+    json?: boolean;
+    color?: 'auto' | 'always' | 'never';
+    quiet?: boolean;
+    streams?: IoStreams;
+}
+export declare class Io {
+    readonly json: boolean;
+    readonly quiet: boolean;
+    readonly stdoutIsTty: boolean;
+    readonly stderrIsTty: boolean;
+    readonly colorEnabled: boolean;
+    private readonly stdout;
+    private readonly stderr;
+    constructor(opts?: IoOptions);
+    /** True when the terminal can host a live-updating view. */
+    get interactive(): boolean;
+    /** Structured data. Always stdout. */
+    write(text: string): void;
+    line(text?: string): void;
+    /**
+     * Emit a JSON document. Values pass through the redactor first, so a stray
+     * token in an API payload cannot be printed or piped into a log.
+     */
+    writeJson(value: unknown): void;
+    /** Human-facing notes. Always stderr, so piped stdout stays clean. */
+    note(text: string): void;
+    /**
+     * Write to stderr even under --quiet or --json.
+     *
+     * Reserved for output the user must see regardless of what they asked to
+     * suppress — specifically the order preview attached to a confirmation
+     * prompt. Being asked to approve an order with none of the facts shown is
+     * not informed consent, whatever the output mode.
+     */
+    forceNote(text: string): void;
+    info(text: string): void;
+    success(text: string): void;
+    warn(text: string): void;
+    error(text: string): void;
+    private paint;
+    bold(text: string): string;
+    dim(text: string): string;
+    red(text: string): string;
+    green(text: string): string;
+    yellow(text: string): string;
+    blue(text: string): string;
+    cyan(text: string): string;
+    magenta(text: string): string;
+    gray(text: string): string;
+    /** Green for positive, red for negative, plain for zero. */
+    signed(value: number, text: string): string;
+    /** Terminal width, with a sane default when stdout is not a TTY. */
+    get columns(): number;
+    get rows(): number;
+}

package/dist/output/io.js

@@ -0,0 +1,143 @@
+import pc from 'picocolors';
+import { redact } from '../core/redact.js';
+export class Io {
+    json;
+    quiet;
+    stdoutIsTty;
+    stderrIsTty;
+    colorEnabled;
+    stdout;
+    stderr;
+    constructor(opts = {}) {
+        this.stdout = opts.streams?.stdout ?? process.stdout;
+        this.stderr = opts.streams?.stderr ?? process.stderr;
+        this.stdoutIsTty = Boolean(this.stdout.isTTY);
+        this.stderrIsTty = Boolean(this.stderr.isTTY);
+        this.json = opts.json ?? false;
+        this.quiet = opts.quiet ?? false;
+        this.colorEnabled = resolveColor(opts.color ?? 'auto', this.stdoutIsTty, this.json);
+    }
+    /** True when the terminal can host a live-updating view. */
+    get interactive() {
+        return this.stdoutIsTty && !this.json;
+    }
+    /** Structured data. Always stdout. */
+    write(text) {
+        this.stdout.write(text);
+    }
+    line(text = '') {
+        this.stdout.write(`${text}\n`);
+    }
+    /**
+     * Emit a JSON document. Values pass through the redactor first, so a stray
+     * token in an API payload cannot be printed or piped into a log.
+     */
+    writeJson(value) {
+        this.stdout.write(`${JSON.stringify(redact(value), null, this.stdoutIsTty ? 2 : 0)}\n`);
+    }
+    /** Human-facing notes. Always stderr, so piped stdout stays clean. */
+    note(text) {
+        if (this.quiet || this.json)
+            return;
+        this.stderr.write(`${text}\n`);
+    }
+    /**
+     * Write to stderr even under --quiet or --json.
+     *
+     * Reserved for output the user must see regardless of what they asked to
+     * suppress — specifically the order preview attached to a confirmation
+     * prompt. Being asked to approve an order with none of the facts shown is
+     * not informed consent, whatever the output mode.
+     */
+    forceNote(text) {
+        this.stderr.write(`${text}\n`);
+    }
+    info(text) {
+        this.note(`${this.dim('·')} ${text}`);
+    }
+    success(text) {
+        this.note(`${this.green('✓')} ${text}`);
+    }
+    warn(text) {
+        if (this.quiet)
+            return;
+        this.stderr.write(`${this.yellow('!')} ${text}\n`);
+    }
+    error(text) {
+        this.stderr.write(`${this.red('✗')} ${text}\n`);
+    }
+    // -- colour helpers, no-ops when colour is disabled ------------------------
+    paint(fn, text) {
+        return this.colorEnabled ? fn(text) : text;
+    }
+    bold(text) {
+        return this.paint(pc.bold, text);
+    }
+    dim(text) {
+        return this.paint(pc.dim, text);
+    }
+    red(text) {
+        return this.paint(pc.red, text);
+    }
+    green(text) {
+        return this.paint(pc.green, text);
+    }
+    yellow(text) {
+        return this.paint(pc.yellow, text);
+    }
+    blue(text) {
+        return this.paint(pc.blue, text);
+    }
+    cyan(text) {
+        return this.paint(pc.cyan, text);
+    }
+    magenta(text) {
+        return this.paint(pc.magenta, text);
+    }
+    gray(text) {
+        return this.paint(pc.gray, text);
+    }
+    /** Green for positive, red for negative, plain for zero. */
+    signed(value, text) {
+        if (value > 0)
+            return this.green(text);
+        if (value < 0)
+            return this.red(text);
+        return text;
+    }
+    /** Terminal width, with a sane default when stdout is not a TTY. */
+    get columns() {
+        const cols = this.stdout.columns;
+        if (typeof cols === 'number' && cols > 0)
+            return cols;
+        const fromEnv = Number(process.env['COLUMNS']);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 80;
+    }
+    get rows() {
+        const rows = this.stdout.rows;
+        return typeof rows === 'number' && rows > 0 ? rows : 24;
+    }
+}
+/**
+ * Resolve whether colour should be used.
+ *
+ * NO_COLOR is honoured whenever it is present and non-empty — per the spec it
+ * is not parsed for truthiness, so NO_COLOR=0 still disables colour.
+ */
+function resolveColor(mode, isTty, json) {
+    if (mode === 'never')
+        return false;
+    if (mode === 'always')
+        return true;
+    const noColor = process.env['NO_COLOR'];
+    if (noColor !== undefined && noColor !== '')
+        return false;
+    const forceColor = process.env['FORCE_COLOR'];
+    if (forceColor !== undefined && forceColor !== '' && forceColor !== '0')
+        return true;
+    if (process.env['TERM'] === 'dumb')
+        return false;
+    if (json)
+        return false;
+    return isTty;
+}

package/dist/output/table.d.ts

@@ -0,0 +1,28 @@
+import type { Io } from './io.js';
+/**
+ * Table rendering.
+ *
+ * cli-table3 is used specifically because it measures column widths with
+ * `string-width`, which is ANSI- and East-Asian-width aware. That matters here:
+ * cells contain the ₹ symbol and colour escapes for P&L, and a naive width
+ * calculation misaligns every column below the first coloured row.
+ */
+export interface Column<T> {
+    header: string;
+    /** Rendered cell content. Colour is allowed; widths account for it. */
+    value: (row: T, io: Io) => string;
+    align?: 'left' | 'right' | 'center';
+}
+export interface TableOptions {
+    /** Omit borders and padding for a denser view. */
+    compact?: boolean;
+    /** Shown instead of the table when there are no rows. */
+    empty?: string;
+}
+export declare function renderTable<T>(io: Io, rows: readonly T[], columns: Array<Column<T>>, opts?: TableOptions): string;
+/** Print a table, or the equivalent JSON when --json is active. */
+export declare function printTable<T>(io: Io, rows: readonly T[], columns: Array<Column<T>>, jsonValue: unknown, opts?: TableOptions): void;
+/** A borderless key/value block, for detail views. */
+export declare function renderKeyValue(io: Io, entries: Array<[string, string]>): string;
+/** A section heading. */
+export declare function heading(io: Io, text: string): string;

package/dist/output/table.js

@@ -0,0 +1,73 @@
+import Table from 'cli-table3';
+export function renderTable(io, rows, columns, opts = {}) {
+    if (rows.length === 0) {
+        return io.dim(opts.empty ?? 'Nothing to show.');
+    }
+    const table = new Table({
+        head: columns.map((column) => io.bold(column.header)),
+        colAligns: columns.map((column) => column.align ?? 'left'),
+        style: {
+            head: [],
+            border: [],
+            compact: opts.compact ?? false,
+            'padding-left': 1,
+            'padding-right': 1,
+        },
+        chars: opts.compact ? COMPACT_CHARS : ROUNDED_CHARS,
+    });
+    for (const row of rows) {
+        table.push(columns.map((column) => column.value(row, io)));
+    }
+    return table.toString();
+}
+/** Print a table, or the equivalent JSON when --json is active. */
+export function printTable(io, rows, columns, jsonValue, opts = {}) {
+    if (io.json) {
+        io.writeJson(jsonValue);
+        return;
+    }
+    io.line(renderTable(io, rows, columns, opts));
+}
+const ROUNDED_CHARS = {
+    top: '─',
+    'top-mid': '┬',
+    'top-left': '╭',
+    'top-right': '╮',
+    bottom: '─',
+    'bottom-mid': '┴',
+    'bottom-left': '╰',
+    'bottom-right': '╯',
+    left: '│',
+    'left-mid': '├',
+    mid: '─',
+    'mid-mid': '┼',
+    right: '│',
+    'right-mid': '┤',
+    middle: '│',
+};
+const COMPACT_CHARS = {
+    top: '',
+    'top-mid': '',
+    'top-left': '',
+    'top-right': '',
+    bottom: '',
+    'bottom-mid': '',
+    'bottom-left': '',
+    'bottom-right': '',
+    left: '',
+    'left-mid': '',
+    mid: '',
+    'mid-mid': '',
+    right: '',
+    'right-mid': '',
+    middle: '  ',
+};
+/** A borderless key/value block, for detail views. */
+export function renderKeyValue(io, entries) {
+    const width = Math.max(...entries.map(([key]) => key.length));
+    return entries.map(([key, value]) => `  ${io.dim(key.padEnd(width))}  ${value}`).join('\n');
+}
+/** A section heading. */
+export function heading(io, text) {
+    return `\n${io.bold(text)}`;
+}

package/dist/run.d.ts

@@ -0,0 +1,15 @@
+import { type ExitCodeValue } from './core/errors.js';
+import { type IoStreams } from './output/io.js';
+export interface RunOptions {
+    argv?: string[];
+    streams?: IoStreams;
+}
+/**
+ * Build and execute the CLI.
+ *
+ * Exported as a function taking argv and streams (rather than reading
+ * process.argv directly) so tests can drive it in-process. That matters
+ * because HTTP mocking cannot reach into a spawned child process — most tests
+ * call this, and only a thin smoke layer spawns the real binary.
+ */
+export declare function run(opts?: RunOptions): Promise<ExitCodeValue>;

package/dist/run.js

@@ -0,0 +1,161 @@
+import { Command, CommanderError } from 'commander';
+import { createContext } from './context.js';
+import { AbortedError, ExitCode, KiteCliError } from './core/errors.js';
+import { redactString } from './core/redact.js';
+import { Io } from './output/io.js';
+const VERSION = '0.1.0';
+/**
+ * Build and execute the CLI.
+ *
+ * Exported as a function taking argv and streams (rather than reading
+ * process.argv directly) so tests can drive it in-process. That matters
+ * because HTTP mocking cannot reach into a spawned child process — most tests
+ * call this, and only a thin smoke layer spawns the real binary.
+ */
+export async function run(opts = {}) {
+    const argv = opts.argv ?? process.argv;
+    // Handlers signal partial failure by setting process.exitCode (e.g. a sliced
+    // order where some legs succeeded). That is a process global, so reset it on
+    // entry — otherwise a second run() in the same process inherits the first
+    // run's failure. Matters for tests and for any embedder.
+    process.exitCode = undefined;
+    // Ctrl-C cancels in-flight requests rather than leaving them dangling.
+    const controller = new AbortController();
+    const onSigint = () => controller.abort(new AbortedError('Interrupted.'));
+    process.once('SIGINT', onSigint);
+    process.once('SIGTERM', onSigint);
+    const program = new Command();
+    let exitCode = ExitCode.Ok;
+    program
+        .name('kite')
+        .description('Unofficial command-line interface for the Zerodha Kite Connect API (not affiliated with Zerodha)')
+        .version(VERSION, '-v, --version')
+        .option('--json', 'Emit JSON instead of formatted tables')
+        .option('--color <when>', 'Colour output: auto, always, or never')
+        // Deliberately no `-q` short form: it would shadow `-q, --quantity` on the
+        // order and GTT subcommands, which is typed far more often than --quiet.
+        .option('--quiet', 'Suppress informational messages')
+        .option('--debug', 'Print redacted request diagnostics to stderr')
+        .option('--env <env>', 'Environment: production or sandbox')
+        .option('-y, --yes', 'Skip confirmation prompts (use with care)')
+        .option('--dry-run', 'Show what would happen without sending anything to Kite')
+        .showHelpAfterError('(run `kite --help` for usage)')
+        .configureOutput({
+        writeOut: (str) => (opts.streams?.stdout ?? process.stdout).write(str),
+        writeErr: (str) => (opts.streams?.stderr ?? process.stderr).write(str),
+    })
+        // Throw instead of calling process.exit, so `run()` stays testable and
+        // always returns its exit code.
+        .exitOverride();
+    /** Wraps a handler with context construction and error reporting. */
+    const withContext = (handler) => async (...args) => {
+        // Commander passes (…arguments, options, command).
+        const command = args[args.length - 1];
+        const options = args[args.length - 2];
+        const globals = program.opts();
+        const ctx = await createContext(globals, controller.signal, opts.streams);
+        try {
+            await handler(ctx, options, command);
+        }
+        catch (err) {
+            exitCode = reportError(err, ctx.io);
+        }
+    };
+    // Registered lazily so a bare `kite quote` never pays to import the
+    // dashboard renderer, the ticker, or the prompt library.
+    const { authCommands } = await import('./commands/auth.js');
+    const { portfolioCommands } = await import('./commands/portfolio.js');
+    const { marketCommands } = await import('./commands/market.js');
+    const { orderCommands } = await import('./commands/orders.js');
+    const { gttCommands } = await import('./commands/gtt.js');
+    const { watchCommands } = await import('./commands/watch.js');
+    const { configCommands } = await import('./commands/config.js');
+    // commandsGroup applies to every command registered after it, so the group
+    // is set immediately before each block. With ~25 commands this is the
+    // difference between a readable --help and a wall of text.
+    program.commandsGroup('Account:');
+    authCommands(program, withContext);
+    program.commandsGroup('Portfolio:');
+    portfolioCommands(program, withContext);
+    program.commandsGroup('Market data:');
+    marketCommands(program, withContext);
+    program.commandsGroup('Trading:');
+    orderCommands(program, withContext);
+    gttCommands(program, withContext);
+    program.commandsGroup('Streaming:');
+    watchCommands(program, withContext);
+    program.commandsGroup('Settings:');
+    configCommands(program, withContext);
+    program.addHelpText('after', `
+Examples:
+  $ kite login                                  Authenticate and store a session
+  $ kite holdings                               Show your portfolio
+  $ kite quote NSE:INFY NSE:TCS                 Live quotes for two symbols
+  $ kite watch --holdings                       Stream your whole portfolio
+  $ kite history NSE:INFY -i 5minute --from 7d  Recent 5-minute candles
+  $ kite orders place NSE:INFY -s BUY -q 1 --dry-run
+                                                Preview an order without sending it
+  $ kite positions --json | jq '.net[].pnl'     Machine-readable output
+
+Safety:
+  Order commands preview the resolved order and ask for confirmation.
+  Use --dry-run to validate without sending, or --yes to skip the prompt.
+  Disable trading entirely with: kite config set trading.enabled false
+`);
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (err) {
+        if (err instanceof CommanderError) {
+            // --help and --version are reported as errors by exitOverride.
+            if (err.code === 'commander.helpDisplayed' || err.code === 'commander.help' || err.code === 'commander.version') {
+                return ExitCode.Ok;
+            }
+            return ExitCode.Usage;
+        }
+        const io = new Io({ ...(opts.streams ? { streams: opts.streams } : {}) });
+        exitCode = reportError(err, io);
+    }
+    finally {
+        process.removeListener('SIGINT', onSigint);
+        process.removeListener('SIGTERM', onSigint);
+    }
+    // A handler may have set process.exitCode directly (e.g. a partially failed
+    // sliced order), which should win over a clean return.
+    if (exitCode === ExitCode.Ok && typeof process.exitCode === 'number' && process.exitCode !== 0) {
+        return process.exitCode;
+    }
+    return exitCode;
+}
+/**
+ * Render an error and choose an exit code.
+ *
+ * Every message is redacted before printing: an API error can echo back input
+ * that contains a token, and a stack trace can contain the WebSocket URL.
+ */
+function reportError(err, io) {
+    if (err instanceof AbortedError) {
+        io.note('');
+        io.error(err.message);
+        return err.exitCode;
+    }
+    if (err instanceof KiteCliError) {
+        io.error(redactString(err.message));
+        if (err.hint)
+            io.note(`  ${io.dim(err.hint)}`);
+        return err.exitCode;
+    }
+    if (err instanceof Error && err.name === 'AbortError') {
+        io.error('Interrupted.');
+        return ExitCode.Aborted;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    io.error(redactString(message));
+    if (err instanceof Error && err.stack && process.env['KITE_DEBUG_STACK'] === '1') {
+        io.note(redactString(err.stack));
+    }
+    else {
+        io.note(io.dim('  Set KITE_DEBUG_STACK=1 for a stack trace.'));
+    }
+    return ExitCode.Failure;
+}