@pungoyal/kite-cli 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,182 @@
+import { redirectUrlFor } from '../core/auth.js';
+import { ConfigSchema, isSettableKey, loadConfig, SETTABLE_KEYS, saveConfig } from '../core/config.js';
+import { getSecret, keyringAvailable } from '../core/credentials.js';
+import { UsageError } from '../core/errors.js';
+import { cacheDir, configDir, configFile } from '../core/paths.js';
+import { maskSecret } from '../core/redact.js';
+import { rupees } from '../output/format.js';
+import { heading, renderKeyValue } from '../output/table.js';
+export const configCommands = (program, run) => {
+    const config = program.command('config').description('View and change CLI settings');
+    config.command('show', { isDefault: true }).description('Show the current configuration').action(run(showConfig));
+    config
+        .command('set')
+        .description('Set a configuration value')
+        .argument('<key>', 'Dotted key, e.g. trading.maxOrderValue')
+        .argument('<value>')
+        .action(run(setConfig));
+    config
+        .command('unset')
+        .description('Remove a configuration value, restoring its default')
+        .argument('<key>')
+        .action(run(unsetConfig));
+    config.command('path').description('Print the paths this CLI reads and writes').action(run(showPaths));
+};
+async function showConfig(ctx) {
+    const { io } = ctx;
+    const config = await loadConfig();
+    if (io.json) {
+        io.writeJson(config);
+        return;
+    }
+    const secret = await getSecret('api_secret', { env: ctx.env });
+    io.line(heading(io, 'Account'));
+    io.line(renderKeyValue(io, [
+        ['API key', config.apiKey ?? io.dim('not set')],
+        ['API secret', secret ? `${maskSecret(secret.value)} (${secret.backend})` : io.dim('not set')],
+        ['Environment', config.env === 'sandbox' ? io.cyan('sandbox') : 'production'],
+        [
+            'Keyring',
+            (await keyringAvailable()) ? io.green('available') : io.yellow('unavailable — using an encrypted file'),
+        ],
+    ]));
+    io.line(heading(io, 'Trading safety'));
+    io.line(renderKeyValue(io, [
+        ['Trading enabled', config.trading.enabled ? io.green('yes') : io.red('no — all order commands will refuse')],
+        ['Confirm orders', config.trading.confirm ? 'yes' : io.yellow('no')],
+        ['Max order value', config.trading.maxOrderValue ? rupees(config.trading.maxOrderValue) : io.dim('no cap')],
+        ['Strict confirm above', rupees(config.trading.strictConfirmAbove)],
+    ]));
+    io.line(heading(io, 'Login callback'));
+    io.line(renderKeyValue(io, [
+        ['Redirect URL', redirectUrlFor(config.redirectPort, config.redirectPath)],
+        ['', io.dim('This must match the redirect URL in your Kite developer console exactly.')],
+    ]));
+    io.line(heading(io, 'Output'));
+    io.line(renderKeyValue(io, [
+        ['Colour', config.output.color],
+        ['Compact tables', config.output.compact ? 'yes' : 'no'],
+    ]));
+    io.note('');
+    io.info(`Config file: ${configFile()}`);
+}
+/**
+ * Values arrive from argv as strings, so they are coerced by inspecting the
+ * default for that key, then re-validated through the full schema. That way an
+ * invalid value is rejected before it is written, rather than breaking every
+ * later invocation.
+ */
+async function setConfig(ctx, _opts, command) {
+    const [key, rawValue] = command.args;
+    if (!key || rawValue === undefined) {
+        throw new UsageError('Both a key and a value are required, e.g. `kite config set trading.enabled false`.');
+    }
+    if (!isSettableKey(key)) {
+        const available = Object.keys(SETTABLE_KEYS).join(', ');
+        throw new UsageError(`Unknown setting "${key}".`, `Available settings: ${available}.`);
+    }
+    const config = await loadConfig();
+    const coerced = coerce(rawValue, SETTABLE_KEYS[key].type, key);
+    const updated = structuredClone(config);
+    writePath(updated, key, coerced);
+    const parsed = ConfigSchema.safeParse(updated);
+    if (!parsed.success) {
+        const { z } = await import('zod');
+        throw new UsageError(`Invalid value for "${key}":\n${z.prettifyError(parsed.error)}`);
+    }
+    await saveConfig(parsed.data);
+    if (ctx.io.json) {
+        ctx.io.writeJson({ key, value: coerced });
+        return;
+    }
+    ctx.io.success(`Set ${ctx.io.bold(key)} to ${JSON.stringify(coerced)}.`);
+    if (key === 'trading.enabled' && coerced === false) {
+        ctx.io.info('The kill switch is on. All order commands will now refuse before contacting Kite.');
+    }
+    if (key === 'redirectPort' || key === 'redirectPath') {
+        const next = await loadConfig();
+        ctx.io.info(`Update your Kite app's redirect URL to ${redirectUrlFor(next.redirectPort, next.redirectPath)}`);
+    }
+}
+async function unsetConfig(ctx, _opts, command) {
+    const key = command.args[0];
+    if (!key)
+        throw new UsageError('A key is required.');
+    if (!isSettableKey(key)) {
+        throw new UsageError(`Unknown setting "${key}".`, `Available settings: ${Object.keys(SETTABLE_KEYS).join(', ')}.`);
+    }
+    const config = await loadConfig();
+    const updated = structuredClone(config);
+    deletePath(updated, key);
+    const parsed = ConfigSchema.safeParse(updated);
+    if (!parsed.success) {
+        const { z } = await import('zod');
+        throw new UsageError(`Cannot unset "${key}":\n${z.prettifyError(parsed.error)}`);
+    }
+    await saveConfig(parsed.data);
+    if (ctx.io.json) {
+        ctx.io.writeJson({ key, unset: true });
+        return;
+    }
+    ctx.io.success(`Unset ${ctx.io.bold(key)}.`);
+}
+async function showPaths(ctx) {
+    const { io } = ctx;
+    const paths = {
+        config: configFile(),
+        configDir: configDir(),
+        cacheDir: cacheDir(),
+    };
+    if (io.json) {
+        io.writeJson(paths);
+        return;
+    }
+    io.line(renderKeyValue(io, [
+        ['Config file', paths.config],
+        ['Config directory', paths.configDir],
+        ['Cache directory', paths.cacheDir],
+        ['Secrets', (await keyringAvailable()) ? 'OS keyring' : `${paths.configDir}/credentials.enc`],
+    ]));
+}
+// ---------------------------------------------------------------------------
+/** Coerce an argv string to the type the setting declares. */
+function coerce(raw, type, key) {
+    if (type === 'boolean') {
+        if (raw === 'true')
+            return true;
+        if (raw === 'false')
+            return false;
+        throw new UsageError(`${key} expects true or false, got "${raw}".`);
+    }
+    if (type === 'number') {
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+            throw new UsageError(`${key} expects a number, got "${raw}".`);
+        return n;
+    }
+    return raw;
+}
+function writePath(target, path, value) {
+    const segments = path.split('.');
+    const last = segments.pop();
+    let node = target;
+    for (const segment of segments) {
+        if (typeof node[segment] !== 'object' || node[segment] === null) {
+            node[segment] = {};
+        }
+        node = node[segment];
+    }
+    node[last] = value;
+}
+function deletePath(target, path) {
+    const segments = path.split('.');
+    const last = segments.pop();
+    let node = target;
+    for (const segment of segments) {
+        const next = node[segment];
+        if (typeof next !== 'object' || next === null)
+            return;
+        node = next;
+    }
+    delete node[last];
+}

package/dist/commands/gtt.d.ts

@@ -0,0 +1,12 @@
+import type { CommandFactory } from './types.js';
+/**
+ * Good Till Triggered orders.
+ *
+ * Two shapes:
+ *   single  — one trigger price, one order
+ *   two-leg — OCO: two trigger prices (stop-loss and target), index-matched to
+ *             two orders; whichever fires first cancels the other
+ *
+ * GTT orders are always LIMIT — the API rejects anything else.
+ */
+export declare const gttCommands: CommandFactory;

package/dist/commands/gtt.js

@@ -0,0 +1,276 @@
+import { PRODUCTS } from '../core/api.js';
+import { ExitCode, KiteCliError, UsageError } from '../core/errors.js';
+import { formatInstrumentKey, parseInstrumentKey } from '../core/instruments.js';
+import { dateOnly, money, quantity, rupees } from '../output/format.js';
+import { heading, printTable, renderKeyValue, renderTable } from '../output/table.js';
+import { assertTradingEnabled, confirmAction } from '../safety.js';
+/**
+ * Good Till Triggered orders.
+ *
+ * Two shapes:
+ *   single  — one trigger price, one order
+ *   two-leg — OCO: two trigger prices (stop-loss and target), index-matched to
+ *             two orders; whichever fires first cancels the other
+ *
+ * GTT orders are always LIMIT — the API rejects anything else.
+ */
+export const gttCommands = (program, run) => {
+    const gtt = program.command('gtt').description('Manage Good Till Triggered orders');
+    gtt
+        .command('list', { isDefault: true })
+        .description('Show your GTT triggers')
+        .option('--active', 'Show only active triggers')
+        .action(run(listGtt));
+    gtt.command('get').description('Show one GTT trigger in detail').argument('<id>').action(run(getGtt));
+    gtt
+        .command('place')
+        .description('Create a GTT trigger')
+        .argument('<instrument>', 'Instrument as EXCHANGE:SYMBOL')
+        .requiredOption('-s, --side <side>', 'BUY or SELL')
+        .requiredOption('-q, --quantity <n>', 'Quantity')
+        .requiredOption('--trigger <price>', 'Trigger price (repeat for a two-leg OCO)', collect, [])
+        .requiredOption('--price <price>', 'Limit price for the resulting order (repeat for two-leg)', collect, [])
+        .option('--product <product>', `Product (${PRODUCTS.join(', ')})`, 'CNC')
+        .action(run(placeGtt));
+    gtt.command('delete').description('Delete a GTT trigger').argument('<id>').action(run(deleteGtt));
+};
+function collect(value, previous) {
+    return [...previous, value];
+}
+async function listGtt(ctx, opts) {
+    ctx.requireSession();
+    const all = await ctx.api.getGtts(ctx.signal);
+    const rows = opts.active ? all.filter((trigger) => trigger.status === 'active') : all;
+    const columns = [
+        { header: 'ID', value: (g, io) => io.dim(String(g.id)) },
+        {
+            header: 'Symbol',
+            value: (g, io) => io.bold(`${g.condition.exchange}:${g.condition.tradingsymbol}`),
+        },
+        { header: 'Type', value: (g) => (g.type === 'two-leg' ? 'OCO' : 'single') },
+        {
+            header: 'Side',
+            value: (g, io) => {
+                const side = g.orders[0]?.transaction_type;
+                return side === 'BUY' ? io.green('BUY') : side === 'SELL' ? io.red('SELL') : '—';
+            },
+        },
+        {
+            header: 'Qty',
+            value: (g) => quantity(g.orders[0]?.quantity),
+            align: 'right',
+        },
+        {
+            header: 'Trigger',
+            value: (g) => g.condition.trigger_values.map((v) => money(v)).join(' / '),
+            align: 'right',
+        },
+        {
+            header: 'LTP',
+            value: (g) => money(g.condition.last_price),
+            align: 'right',
+        },
+        { header: 'Status', value: (g, io) => colourGttStatus(io, g.status) },
+        { header: 'Expires', value: (g) => dateOnly(g.expires_at) },
+    ];
+    printTable(ctx.io, rows, columns, rows, {
+        compact: ctx.config.output.compact,
+        empty: opts.active ? 'No active GTT triggers.' : 'No GTT triggers.',
+    });
+}
+function colourGttStatus(io, status) {
+    switch (status) {
+        case 'active':
+            return io.green(status);
+        case 'triggered':
+            return io.yellow(status);
+        case 'cancelled':
+        case 'deleted':
+        case 'expired':
+            return io.dim(status);
+        case 'rejected':
+            return io.red(status);
+        default:
+            return status;
+    }
+}
+async function getGtt(ctx, _opts, command) {
+    ctx.requireSession();
+    const id = requireId(command.args[0]);
+    const trigger = await ctx.api.getGtt(id, ctx.signal);
+    if (ctx.io.json) {
+        ctx.io.writeJson(trigger);
+        return;
+    }
+    const { io } = ctx;
+    io.line(heading(io, `GTT ${trigger.id}`));
+    io.line(renderKeyValue(io, [
+        ['Instrument', `${trigger.condition.exchange}:${trigger.condition.tradingsymbol}`],
+        ['Type', trigger.type === 'two-leg' ? 'two-leg (OCO)' : 'single'],
+        ['Status', colourGttStatus(io, trigger.status)],
+        ['Trigger prices', trigger.condition.trigger_values.map((v) => money(v)).join(' / ')],
+        ['Last price', money(trigger.condition.last_price)],
+        ['Created', dateOnly(trigger.created_at)],
+        ['Expires', dateOnly(trigger.expires_at)],
+    ]));
+    io.line(heading(io, 'Orders'));
+    io.line(renderTableFor(ctx, trigger.orders, [
+        {
+            header: 'Side',
+            value: (o, io) => (o.transaction_type === 'BUY' ? io.green('BUY') : io.red('SELL')),
+        },
+        { header: 'Qty', value: (o) => quantity(o.quantity), align: 'right' },
+        { header: 'Price', value: (o) => money(o.price), align: 'right' },
+        { header: 'Product', value: (o) => o.product ?? '—' },
+        { header: 'Type', value: (o) => o.order_type ?? '—' },
+    ]));
+}
+async function placeGtt(ctx, opts, command) {
+    ctx.requireSession();
+    assertTradingEnabled(ctx);
+    if (ctx.env === 'sandbox') {
+        throw new KiteCliError('The sandbox does not support GTT.', ExitCode.Input);
+    }
+    const instrumentArg = command.args[0];
+    if (!instrumentArg)
+        throw new UsageError('An instrument is required.');
+    const instrument = parseInstrumentKey(instrumentArg);
+    const instrumentKey = formatInstrumentKey(instrument.exchange, instrument.tradingsymbol);
+    const side = opts.side.toUpperCase();
+    if (side !== 'BUY' && side !== 'SELL')
+        throw new UsageError('--side must be BUY or SELL.');
+    const qty = Number(opts.quantity);
+    if (!Number.isInteger(qty) || qty <= 0)
+        throw new UsageError('--quantity must be a positive whole number.');
+    const triggers = opts.trigger.map((value) => requirePrice(value, '--trigger'));
+    const prices = opts.price.map((value) => requirePrice(value, '--price'));
+    if (triggers.length !== prices.length) {
+        throw new UsageError(`Got ${triggers.length} trigger price(s) and ${prices.length} limit price(s).`, 'Each --trigger needs a matching --price, in the same order.');
+    }
+    if (triggers.length !== 1 && triggers.length !== 2) {
+        throw new UsageError('A GTT takes either 1 trigger (single) or 2 triggers (two-leg OCO).');
+    }
+    const product = normaliseProduct(opts.product ?? 'CNC');
+    const type = triggers.length === 2 ? 'two-leg' : 'single';
+    // The trigger condition needs a current last_price, and Kite validates it.
+    const ltpMap = await ctx.api.getLtp([instrumentKey], ctx.signal);
+    const lastPrice = ltpMap[instrumentKey]?.last_price;
+    if (lastPrice === undefined) {
+        throw new KiteCliError(`Could not fetch a last price for ${instrumentKey}, which a GTT requires.`, ExitCode.Input, 'Check the symbol with `kite instruments search`.');
+    }
+    const params = {
+        type,
+        condition: {
+            exchange: instrument.exchange,
+            tradingsymbol: instrument.tradingsymbol,
+            trigger_values: triggers,
+            last_price: lastPrice,
+        },
+        orders: triggers.map((_, index) => ({
+            exchange: instrument.exchange,
+            tradingsymbol: instrument.tradingsymbol,
+            transaction_type: side,
+            quantity: qty,
+            // GTT only supports LIMIT orders.
+            order_type: 'LIMIT',
+            product,
+            price: prices[index],
+        })),
+    };
+    const notionalValue = Math.max(...prices) * qty;
+    await confirmAction(ctx, {
+        action: `Create ${type} GTT for ${qty} ${instrument.tradingsymbol}`,
+        mutatesOrders: true,
+        // A GTT places a real order when it triggers.
+        increasesExposure: true,
+        notionalValue,
+        challengeToken: instrument.tradingsymbol,
+        details: [
+            { label: 'Instrument', value: instrumentKey },
+            { label: 'Type', value: type === 'two-leg' ? 'two-leg (OCO)' : 'single' },
+            {
+                label: 'Side',
+                value: side === 'BUY' ? ctx.io.green(side) : ctx.io.red(side),
+            },
+            { label: 'Quantity', value: quantity(qty) },
+            { label: 'Last price', value: rupees(lastPrice) },
+            ...triggers.map((trigger, index) => ({
+                label: type === 'two-leg' ? (index === 0 ? 'Leg 1' : 'Leg 2') : 'Trigger',
+                value: `trigger at ${rupees(trigger)} → LIMIT ${rupees(prices[index])}`,
+            })),
+            { label: 'Product', value: product },
+            { label: 'Max value', value: rupees(notionalValue) },
+        ],
+    });
+    if (ctx.options.dryRun)
+        return;
+    const result = await ctx.api.placeGtt(params, ctx.signal);
+    if (ctx.io.json) {
+        ctx.io.writeJson(result);
+        return;
+    }
+    ctx.io.success(`GTT created: ${ctx.io.bold(String(result.trigger_id))}`);
+    ctx.io.info('GTT triggers expire after one year, or when Kite invalidates them.');
+}
+async function deleteGtt(ctx, _opts, command) {
+    ctx.requireSession();
+    assertTradingEnabled(ctx);
+    const id = requireId(command.args[0]);
+    // Enrichment for the preview. Deleting a GTT only removes a pending trigger,
+    // so a failed lookup does not need to block — but the user must be told the
+    // preview below is unverified rather than silently shown "unknown".
+    let existing;
+    try {
+        existing = await ctx.api.getGtt(id, ctx.signal);
+    }
+    catch {
+        ctx.io.warn(`Could not read GTT ${id} from Kite; the details below are unverified.`);
+    }
+    await confirmAction(ctx, {
+        action: `Delete GTT ${id}`,
+        mutatesOrders: true,
+        details: [
+            { label: 'GTT ID', value: String(id) },
+            {
+                label: 'Instrument',
+                value: existing ? `${existing.condition.exchange}:${existing.condition.tradingsymbol}` : 'unknown',
+            },
+            { label: 'Status', value: existing?.status ?? 'unknown' },
+            {
+                label: 'Triggers',
+                value: existing ? existing.condition.trigger_values.map((v) => money(v)).join(' / ') : 'unknown',
+            },
+        ],
+    });
+    if (ctx.options.dryRun)
+        return;
+    const result = await ctx.api.deleteGtt(id, ctx.signal);
+    if (ctx.io.json) {
+        ctx.io.writeJson(result);
+        return;
+    }
+    ctx.io.success(`GTT ${result.trigger_id} deleted.`);
+}
+function requireId(value) {
+    const id = Number(value);
+    if (!Number.isInteger(id) || id <= 0)
+        throw new UsageError('A numeric GTT ID is required.');
+    return id;
+}
+function requirePrice(value, flag) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        throw new UsageError(`${flag} must be a positive number.`);
+    return n;
+}
+function normaliseProduct(value) {
+    const upper = value.toUpperCase();
+    if (PRODUCTS.includes(upper))
+        return upper;
+    throw new UsageError(`Unknown product "${value}".`, `Valid products: ${PRODUCTS.join(', ')}.`);
+}
+function renderTableFor(ctx, rows, columns) {
+    return renderTable(ctx.io, rows, columns, {
+        compact: ctx.config.output.compact,
+    });
+}

package/dist/commands/market.d.ts

@@ -0,0 +1,2 @@
+import type { CommandFactory } from './types.js';
+export declare const marketCommands: CommandFactory;