@pungoyal/kite-cli 0.4.0 → 0.5.0

package/README.md

@@ -28,6 +28,52 @@ $ kite holdings
   Day's change  +₹287.40
 ```
 
+## Why you can trust it
+
+It places real orders with real money, under an unofficial banner — so the safety
+is built into the architecture, and every claim below is verifiable rather than
+aspirational:
+
+- **Try it risk-free first.** Zerodha runs a public sandbox with fake money and no
+  subscription. `kite login --env sandbox` gives you a full session to rehearse
+  every command against before you ever point it at your own account.
+- **It never silently moves money.** Every order previews the *resolved* order —
+  the actual contract, lot size and computed value, not an echo of your flags —
+  and waits for confirmation. There is deliberately no config key that turns that
+  off ([Safety](#safety)).
+- **It never blindly retries a write.** Kite has no idempotency key, so a
+  timed-out order is genuinely ambiguous. Rather than retry, the CLI tags every
+  order and reconciles against the orderbook to tell you what actually happened
+  ([Safety](#safety)).
+- **Your secrets stay put.** The API secret lives in your OS keyring (or an
+  encrypted file), is never accepted as a command-line argument, and is scrubbed
+  from every log, error and stack trace — with [tests](https://github.com/pungoyal/kite-cli/blob/main/test/redact.test.ts)
+  that prove it ([Security](#security)).
+- **Verifiable builds.** Published only from CI via [npm Trusted Publishing](https://docs.npmjs.com/trusted-publishers/)
+  (OIDC, no long-lived token). Check the provenance yourself with `npm audit signatures`.
+- **A small, auditable surface.** ~10 direct dependencies, most of them
+  zero-dependency, enforced by a dependency budget in CI.
+
+## How it compares
+
+Zerodha maintains excellent official SDKs — [`pykiteconnect`](https://github.com/zerodha/pykiteconnect)
+and [`kiteconnectjs`](https://github.com/zerodha/kiteconnectjs). If you're building an
+application, reach for those: they give you the full API, programmatically, and they're
+the foundation the whole ecosystem is built on. `kite-cli` is complementary — the same
+API as a ready-to-use tool, for when you'd rather not write code:
+
+- **Zero code for everyday use.** `kite holdings`, `kite watch --holdings`,
+  `kite orders place …` run straight from the shell — and from any language that can
+  shell out.
+- **An opinionated safety layer.** A kill switch, per-order value cap, resolved-order
+  confirmation, and unique-tag reconciliation for ambiguous writes come built in —
+  decisions the official SDKs deliberately leave open so each application can make its
+  own.
+- **Composable output.** Every command speaks `--json` on stdout, so it drops
+  straight into `jq`, cron jobs, and pipelines.
+- **A library too, when you need one.** The same client is [exported](#library-use),
+  so you can start in the shell and drop into code without switching tools.
+
 ## Install
 
 ```bash
@@ -38,7 +84,21 @@ Requires **Node 22.12 or newer**.
 
 ## Getting started
 
-You need a [Kite Connect](https://developers.kite.trade) app to get an API key and secret. Set your app's redirect URL to:
+**Kick the tyres first — no account, no subscription, no risk.** Zerodha runs a
+public sandbox with fake money, and every command behaves exactly as it does
+against a real account:
+
+```bash
+kite login --env sandbox
+kite --env sandbox holdings
+kite --env sandbox orders place NSE:INFY --side BUY --quantity 1 --dry-run
+```
+
+Learn the commands and see the confirmations there before any real money is
+involved.
+
+**Then connect your own account.** You need a [Kite Connect](https://developers.kite.trade)
+app to get an API key and secret. Set your app's redirect URL to:
 
 ```
 http://127.0.0.1:51101/callback
@@ -52,13 +112,6 @@ kite login
 
 This opens your browser, you log in to Zerodha normally (including your TOTP), and the CLI captures the callback on loopback. The login URL is also printed to the terminal — press `c` while it's waiting to copy it to your clipboard (handy if the browser didn't open, or you want to log in on another device). Your API secret goes into your OS keyring; the daily access token is stored alongside it.
 
-**Want to try it without a subscription or real money?** Zerodha runs a public sandbox:
-
-```bash
-kite login --env sandbox
-kite --env sandbox holdings
-```
-
 **Running more than one Zerodha account?** See [Multiple accounts](#multiple-accounts).
 
 ## Usage
@@ -147,6 +200,7 @@ kite orders list --open                # working orders only
 kite orders get 250720000123456        # full state history and fills
 kite orders modify <id> --price 1520
 kite orders cancel <id>
+kite orders reconcile <tag>            # did an order that seemed to fail actually reach Kite?
 kite trades                            # today's fills
 
 kite gtt list
@@ -245,6 +299,31 @@ kite whoami --json || kite login       # exit code 3 means "no session"
 
 `NO_COLOR` is honoured, and colour is disabled automatically when stdout is not a TTY.
 
+### Agents (MCP)
+
+`kite mcp` exposes Kite's **read-only** endpoints to an LLM agent over the
+[Model Context Protocol](https://modelcontextprotocol.io), so Claude — or any MCP
+client — can answer "how's my portfolio doing?" against live data. It can read
+your profile, holdings, positions, funds, orders, trades, quotes and instruments;
+it **cannot** place, modify or cancel anything. Trading stays at a
+human-confirmed terminal, by design.
+
+Point an MCP client at it — try the sandbox first:
+
+```json
+{
+  "mcpServers": {
+    "kite": {
+      "command": "kite",
+      "args": ["mcp", "--env", "sandbox"]
+    }
+  }
+}
+```
+
+Drop the `--env sandbox` args to run against your real account (still read-only).
+The server needs a live session, so `kite login` first.
+
 ## Multiple accounts
 
 If you run more than one Zerodha account — your own, a family member's, an HUF — each
@@ -329,6 +408,17 @@ $ kite orders place NSE:INFY -s BUY -q 10 --type LIMIT --price 1500 --yes
 · It was not placed twice. Do not re-run this command.
 ```
 
+That reconciliation happens automatically, but only while the placing process is alive. If you lose it — a killed shell, a crashed script, a slept laptop — run it again on demand:
+
+```console
+$ kite orders reconcile kcmrt88o648c1bce
+✓ Found an order for tag kcmrt88o648c1bce:
+  … COMPLETE …
+· If placing this order looked like it failed, it went through — do not place it again.
+```
+
+With no tag, `kite orders reconcile` lists the orders this CLI placed today, and `--json` carries a `placed` boolean for scripts.
+
 Automatic retries are restricted to `GET`/`HEAD` at the transport layer. `POST`, `PUT` and `DELETE` are never retried — in this API those are place, modify and cancel.
 
 ## Security
@@ -394,6 +484,8 @@ searchable site at **[pungoyal.github.io/kite-cli](https://pungoyal.github.io/ki
 
 - [Safety model](https://pungoyal.github.io/kite-cli/safety) — the full layered safety model (kill
   switch, value cap, confirmation escalation, order-tag reconciliation).
+- [MCP server](https://pungoyal.github.io/kite-cli/mcp) — the read-only Model Context Protocol
+  server for LLM agents: its tools, setup, and why it exposes no writes.
 - [Configuration](https://pungoyal.github.io/kite-cli/configuration) — every config key and
   environment variable, with precedence.
 - [Troubleshooting](https://pungoyal.github.io/kite-cli/troubleshooting) — symptom-first fixes

package/dist/commands/mcp.d.ts

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

package/dist/commands/mcp.js

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import { McpServer } from '../core/mcp.js';
+/**
+ * `kite mcp` — a read-only Model Context Protocol server over stdio.
+ *
+ * Launched by an MCP client (Claude and others) as a subprocess, it lets an
+ * agent inspect a Kite account — holdings, positions, funds, live quotes, the
+ * orderbook, instrument search — but never place, modify or cancel an order.
+ * The rationale for read-only lives in src/core/mcp.ts.
+ *
+ * The stdio contract is strict: the JSON-RPC protocol owns stdout, so every
+ * human-facing message here goes to stderr (io.info/note already do).
+ */
+// Single source of truth for the version, like run.ts. package.json sits two
+// levels up from both src/commands/ (dev) and dist/commands/ (published).
+const VERSION = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+/** Instruments accepted by quote-style tools, e.g. ["NSE:INFY", "NSE:TCS"]. */
+const instrumentsArg = z.object({
+    instruments: z.array(z.string().min(1)).min(1).describe('Instruments as EXCHANGE:TRADINGSYMBOL, e.g. NSE:INFY'),
+});
+const searchArg = z.object({
+    query: z.string().min(1).describe('Free-text query over trading symbol and name'),
+    exchange: z.string().optional().describe('Restrict to an exchange, e.g. NSE, NFO'),
+    type: z.string().optional().describe('Restrict to an instrument type, e.g. EQ, CE, PE, FUT'),
+    limit: z.number().int().positive().max(100).optional().describe('Maximum results (default 25)'),
+});
+/** Build one tool, deriving its advertised JSON Schema from the zod schema. */
+function tool(name, description, schema, handler) {
+    return {
+        name,
+        description,
+        schema,
+        inputSchema: z.toJSONSchema(schema),
+        handler,
+    };
+}
+/** The read-only Kite surface exposed to an agent. */
+function buildTools(ctx) {
+    const { api, instruments, signal } = ctx;
+    const noArgs = z.object({});
+    return [
+        tool('get_profile', 'The authenticated Kite user profile.', noArgs, () => api.getProfile(signal)),
+        tool('get_holdings', 'Long-term holdings with average price and P&L.', noArgs, () => api.getHoldings(signal)),
+        tool('get_positions', 'Open positions (intraday and overnight).', noArgs, () => api.getPositions(signal)),
+        tool('get_funds', 'Available margins and cash balance.', noArgs, () => api.getMargins(signal)),
+        tool('get_orders', "Today's orderbook, including status and fills.", noArgs, () => api.getOrders(signal)),
+        tool('get_trades', "Today's executed trades.", noArgs, () => api.getTrades(signal)),
+        tool('quote', 'Full market quotes for one or more instruments.', instrumentsArg, (a) => api.getQuote(a.instruments, signal)),
+        tool('ltp', 'Last traded price for one or more instruments.', instrumentsArg, (a) => api.getLtp(a.instruments, signal)),
+        tool('ohlc', 'Open/high/low/close plus last price for one or more instruments.', instrumentsArg, (a) => api.getOhlc(a.instruments, signal)),
+        tool('search_instruments', 'Find tradeable instruments by symbol or name.', searchArg, async (a) => {
+            await instruments.load({ signal });
+            return instruments.search(a.query, {
+                exchange: a.exchange,
+                type: a.type,
+                ...(a.limit !== undefined ? { limit: a.limit } : {}),
+            });
+        }),
+    ];
+}
+async function mcp(ctx) {
+    // A live session is required — every tool hits the API. Fail here (exit 3)
+    // rather than starting a server whose every call would 403.
+    ctx.requireSession();
+    const server = new McpServer({
+        name: 'kite-cli',
+        version: VERSION,
+        tools: buildTools(ctx),
+        signal: ctx.signal,
+    });
+    ctx.io.info('kite MCP server ready on stdio (read-only). Launch this from an MCP client; Ctrl-C to stop.');
+    if (ctx.env === 'sandbox')
+        ctx.io.info('Running against the sandbox — no real account.');
+    // stdio is the transport: the process's own stdin/stdout carry JSON-RPC.
+    await server.serve(process.stdin, process.stdout);
+}
+export const mcpCommands = (program, run) => {
+    program
+        .command('mcp')
+        .description('Run a read-only MCP server over stdio for LLM agents (Claude and others)')
+        .action(run(mcp));
+};

package/dist/commands/orders.js

@@ -5,7 +5,7 @@ import { formatInstrumentKey, parseInstrumentKey } from '../core/instruments.js'
 import { TERMINAL_ORDER_STATUSES } from '../core/schemas.js';
 import { dateTime, money, quantity, rupees, timeOnly } from '../output/format.js';
 import { heading, printTable, renderKeyValue, renderTable } from '../output/table.js';
-import { assertTradingEnabled, buildOrderTag, confirmAction } from '../safety.js';
+import { assertTradingEnabled, buildOrderTag, CLI_TAG_PREFIX, confirmAction } from '../safety.js';
 export const orderCommands = (program, run) => {
     const orders = program.command('orders').description('View and manage orders');
     orders
@@ -18,6 +18,11 @@ export const orderCommands = (program, run) => {
         .description('Show the full state history of one order')
         .argument('<order-id>')
         .action(run(getOrder));
+    orders
+        .command('reconcile')
+        .description('Check whether a tagged order reached Kite (recovery after an ambiguous failure)')
+        .argument('[tag]', 'Order tag to look up; omit to list the orders this CLI placed today')
+        .action(run(reconcileOrders));
     orders
         .command('place')
         .description('Place an order')
@@ -473,6 +478,75 @@ async function reconcileAfterFailure(ctx, tag, cause) {
         process.exitCode = ExitCode.Upstream;
     }
 }
+/**
+ * Standalone, after-the-fact reconciliation for the no-idempotency problem.
+ *
+ * `orders place` reconciles automatically the instant a placement fails (see
+ * {@link reconcileAfterFailure}), but that check lives and dies with the
+ * process — a killed shell, a crashed script, a slept laptop and it is gone.
+ * This re-runs it on demand. Given the unique tag every order carries, it
+ * answers the only question that matters after an ambiguous failure — "did it
+ * actually reach Kite?" — so you know whether it is safe to place again.
+ *
+ * With a tag, it looks that tag up. With none, it lists the orders this CLI
+ * placed today (those carrying the {@link CLI_TAG_PREFIX} prefix), so you can
+ * still find one whose exact tag you did not capture. It is a query, not a
+ * mutation: it exits 0 on any clean answer, and the `--json` `placed` flag is
+ * the machine-readable verdict.
+ */
+async function reconcileOrders(ctx, _opts, command) {
+    ctx.requireSession();
+    const { io } = ctx;
+    const tag = command.args[0];
+    if (tag) {
+        const matches = await ctx.api.findOrderByTag(tag, ctx.signal);
+        if (io.json) {
+            io.writeJson({ tag, placed: matches.length > 0, order_ids: matches.map((o) => o.order_id), orders: matches });
+            return;
+        }
+        if (matches.length === 0) {
+            io.warn(`No order found for tag ${io.bold(tag)}.`);
+            io.info('If a placement looked like it failed, it most likely did not reach Kite — but check `kite orders list` before retrying, in case it simply has not appeared yet.');
+            return;
+        }
+        io.success(`Found ${matches.length === 1 ? 'an order' : `${matches.length} orders`} for tag ${io.bold(tag)}:`);
+        io.line(renderTableFor(ctx, matches, reconcileColumns()));
+        io.info('If placing this order looked like it failed, it went through — do not place it again.');
+        return;
+    }
+    const mine = (await ctx.api.getOrders(ctx.signal)).filter(hasCliTag);
+    printTable(io, mine, reconcileColumns(), mine, {
+        compact: ctx.config.output.compact,
+        empty: `No orders tagged by this CLI today (looking for the \`${CLI_TAG_PREFIX}\` prefix).`,
+    });
+    if (mine.length > 0 && !io.json) {
+        io.info('Reconcile a specific one with `kite orders reconcile <tag>`.');
+    }
+}
+/** True if this order carries a CLI-generated tag (see {@link CLI_TAG_PREFIX}). */
+function hasCliTag(order) {
+    if (order.tag?.startsWith(CLI_TAG_PREFIX))
+        return true;
+    return order.tags?.some((t) => t.startsWith(CLI_TAG_PREFIX)) ?? false;
+}
+function reconcileColumns() {
+    return [
+        { header: 'Time', value: (o) => timeOnly(o.order_timestamp) },
+        { header: 'Order ID', value: (o, io) => io.dim(o.order_id) },
+        { header: 'Symbol', value: (o, io) => io.bold(o.tradingsymbol ?? '—') },
+        {
+            header: 'Side',
+            value: (o, io) => o.transaction_type === 'BUY' ? io.green('BUY') : o.transaction_type === 'SELL' ? io.red('SELL') : '—',
+        },
+        {
+            header: 'Qty',
+            value: (o) => `${quantity(o.filled_quantity ?? 0)}/${quantity(o.quantity ?? 0)}`,
+            align: 'right',
+        },
+        { header: 'Status', value: (o, io) => colourStatus(io, o.status) },
+        { header: 'Tag', value: (o) => o.tag ?? '—' },
+    ];
+}
 // ---------------------------------------------------------------------------
 // Modify / cancel
 // ---------------------------------------------------------------------------

package/dist/commands/register.js

@@ -49,6 +49,7 @@ export async function registerCommands(program, run) {
     const { configCommands } = await import('./config.js');
     const { doctorCommands } = await import('./doctor.js');
     const { completionCommands } = await import('./completion.js');
+    const { mcpCommands } = await import('./mcp.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.
@@ -68,6 +69,8 @@ export async function registerCommands(program, run) {
     marginCommands(program, run);
     program.commandsGroup('Streaming:');
     watchCommands(program, run);
+    program.commandsGroup('Integrations:');
+    mcpCommands(program, run);
     program.commandsGroup('Settings:');
     configCommands(program, run);
     doctorCommands(program, run);

package/dist/core/mcp.d.ts

@@ -0,0 +1,56 @@
+import type { z } from 'zod';
+/** A tool the agent may call. `schema` validates the arguments before dispatch. */
+export interface McpTool<S extends z.ZodType = z.ZodType> {
+    name: string;
+    description: string;
+    schema: S;
+    /** JSON Schema for the arguments, advertised in `tools/list`. */
+    inputSchema: Record<string, unknown>;
+    handler: (args: z.infer<S>, signal?: AbortSignal) => Promise<unknown> | unknown;
+}
+export interface McpServerOptions {
+    name: string;
+    version: string;
+    tools: McpTool[];
+    /** Aborting this stops the serve loop after the in-flight message. */
+    signal?: AbortSignal | undefined;
+}
+interface JsonRpcRequest {
+    jsonrpc?: unknown;
+    id?: string | number | null;
+    method?: unknown;
+    params?: unknown;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare class McpServer {
+    private readonly tools;
+    private readonly name;
+    private readonly version;
+    private readonly signal;
+    constructor(opts: McpServerOptions);
+    /**
+     * Handle a single decoded JSON-RPC message.
+     *
+     * Returns the response to write back, or `null` for a notification (a request
+     * with no `id`), which by JSON-RPC must never be answered — even on error.
+     */
+    handle(request: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    private initializeResult;
+    private toolList;
+    private callTool;
+    /**
+     * Read newline-delimited JSON-RPC from `input` and write responses to
+     * `output`, until the input closes or the abort signal fires.
+     */
+    serve(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): Promise<void>;
+}
+export {};

package/dist/core/mcp.js

@@ -0,0 +1,166 @@
+import { createInterface } from 'node:readline';
+import { redact, redactString } from './redact.js';
+/**
+ * A minimal Model Context Protocol (MCP) server over stdio.
+ *
+ * MCP lets an LLM agent (Claude and others) call tools exposed by a local
+ * process. This server exposes Kite's *read* endpoints so an agent can inspect a
+ * portfolio, quotes and the orderbook — never place, modify or cancel anything.
+ *
+ * Two deliberate design choices, both flowing from this repo's own principles:
+ *
+ *  - **Hand-rolled, not the official SDK.** A minimal dependency tree is a
+ *    security property here (see scripts/check-deps.mjs), and the SDK pulls a
+ *    heavy transitive closure. The stdio transport is newline-delimited JSON-RPC
+ *    2.0 — small enough to implement directly and unit-test in full.
+ *  - **Read-only.** A money-moving command must render the resolved order and
+ *    obtain confirmation (see src/safety.ts), and an MCP server has no terminal
+ *    to confirm at. Rather than weaken that invariant, writes are simply not
+ *    exposed. An agent that wants to trade must hand back to a human at a TTY.
+ *
+ * The transport framing is newline-delimited JSON: one JSON message per line,
+ * no embedded newlines, no Content-Length headers (that is the HTTP transport,
+ * not stdio).
+ */
+/** Latest protocol revision this server speaks. Echoed back if a client asks. */
+const DEFAULT_PROTOCOL_VERSION = '2025-06-18';
+// Standard JSON-RPC 2.0 error codes.
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INTERNAL_ERROR = -32603;
+export class McpServer {
+    tools;
+    name;
+    version;
+    signal;
+    constructor(opts) {
+        this.tools = opts.tools;
+        this.name = opts.name;
+        this.version = opts.version;
+        this.signal = opts.signal;
+    }
+    /**
+     * Handle a single decoded JSON-RPC message.
+     *
+     * Returns the response to write back, or `null` for a notification (a request
+     * with no `id`), which by JSON-RPC must never be answered — even on error.
+     */
+    async handle(request) {
+        const isNotification = request?.id === undefined;
+        const id = request?.id ?? null;
+        if (request?.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+            return isNotification ? null : error(id, INVALID_REQUEST, 'Invalid Request');
+        }
+        const { method, params } = request;
+        try {
+            switch (method) {
+                case 'initialize':
+                    return ok(id, this.initializeResult(params));
+                case 'ping':
+                    return ok(id, {});
+                case 'tools/list':
+                    return ok(id, { tools: this.toolList() });
+                case 'tools/call':
+                    return ok(id, await this.callTool(params));
+                default:
+                    // Unknown notifications (e.g. notifications/initialized, .../cancelled)
+                    // are ignored; unknown requests get a method-not-found error.
+                    return isNotification ? null : error(id, METHOD_NOT_FOUND, `Method not found: ${method}`);
+            }
+        }
+        catch (err) {
+            // A thrown error here is an internal fault, not a tool-level failure (those
+            // are reported in-band via isError). Redact: the message could echo input.
+            return isNotification ? null : error(id, INTERNAL_ERROR, redactString(messageOf(err)));
+        }
+    }
+    initializeResult(params) {
+        // Speak the client's requested revision when it names one, so we interoperate
+        // with older clients; otherwise advertise our latest.
+        const requested = params?.protocolVersion;
+        return {
+            protocolVersion: typeof requested === 'string' ? requested : DEFAULT_PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: { name: this.name, version: this.version },
+        };
+    }
+    toolList() {
+        return this.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }));
+    }
+    async callTool(params) {
+        const name = params?.name;
+        const tool = this.tools.find((t) => t.name === name);
+        if (!tool) {
+            return toolError(`Unknown tool: ${typeof name === 'string' ? name : String(name)}`);
+        }
+        const rawArgs = params.arguments ?? {};
+        const parsed = tool.schema.safeParse(rawArgs);
+        if (!parsed.success) {
+            return toolError(`Invalid arguments for ${tool.name}: ${redactString(parsed.error.message)}`);
+        }
+        try {
+            const data = await tool.handler(parsed.data, this.signal);
+            // Redact tool output too: this is a fresh egress channel, and a Kite
+            // response or error could carry a value we treat as secret. (Redaction
+            // invariant — see src/core/redact.ts.)
+            return { content: [{ type: 'text', text: JSON.stringify(redact(data)) }] };
+        }
+        catch (err) {
+            // Tool failures are surfaced to the model in-band, so it can react (retry a
+            // different symbol, tell the user to log in), not as a transport error.
+            return toolError(redactString(messageOf(err)));
+        }
+    }
+    /**
+     * Read newline-delimited JSON-RPC from `input` and write responses to
+     * `output`, until the input closes or the abort signal fires.
+     */
+    async serve(input, output) {
+        const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+        const onAbort = () => rl.close();
+        this.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            for await (const line of rl) {
+                const trimmed = line.trim();
+                if (trimmed === '')
+                    continue;
+                let response;
+                let request;
+                try {
+                    request = JSON.parse(trimmed);
+                }
+                catch {
+                    response = error(null, PARSE_ERROR, 'Parse error');
+                    output.write(`${JSON.stringify(response)}\n`);
+                    continue;
+                }
+                response = await this.handle(request);
+                if (response)
+                    output.write(`${JSON.stringify(response)}\n`);
+                if (this.signal?.aborted)
+                    break;
+            }
+        }
+        finally {
+            this.signal?.removeEventListener('abort', onAbort);
+            rl.close();
+        }
+    }
+}
+function ok(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+function error(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+}
+function toolError(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export { type ClientOptions, KiteClient, setDispatcher, } from './core/client.js
 export { type Endpoints, type Environment, endpointsFor, SANDBOX_CREDENTIALS, } from './core/config.js';
 export { AuthRequiredError, ExitCode, KiteApiError, KiteCliError, type KiteErrorType, NetworkError, UsageError, } from './core/errors.js';
 export { InstrumentStore, parseInstrumentKey, parseInstrumentsCsv, } from './core/instruments.js';
+export { McpServer, type McpServerOptions, type McpTool, } from './core/mcp.js';
 export { DEFAULT_PROFILE, getProfile, listProfileNames, type ResolvedProfile, resolveProfile, resolveTradingConfig, SANDBOX_PROFILE, storagePrefixFor, } from './core/profiles.js';
 export { ORDER_LIMITS, type RateCategory, RateLimiter, } from './core/ratelimit.js';
 export { maskSecret, redact, redactString, redactUrl, registerSecret, } from './core/redact.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export { KiteClient, setDispatcher, } from './core/client.js';
 export { endpointsFor, SANDBOX_CREDENTIALS, } from './core/config.js';
 export { AuthRequiredError, ExitCode, KiteApiError, KiteCliError, NetworkError, UsageError, } from './core/errors.js';
 export { InstrumentStore, parseInstrumentKey, parseInstrumentsCsv, } from './core/instruments.js';
+export { McpServer, } from './core/mcp.js';
 export { DEFAULT_PROFILE, getProfile, listProfileNames, resolveProfile, resolveTradingConfig, SANDBOX_PROFILE, storagePrefixFor, } from './core/profiles.js';
 export { ORDER_LIMITS, RateLimiter, } from './core/ratelimit.js';
 export { maskSecret, redact, redactString, redactUrl, registerSecret, } from './core/redact.js';

package/dist/run.js

@@ -35,7 +35,7 @@ export async function run(opts = {}) {
     let exitCode = ExitCode.Ok;
     program
         .name('kite')
-        .description('Unofficial command-line interface for the Zerodha Kite Connect API (not affiliated with Zerodha)')
+        .description('Unofficial, safety-first CLI for the Zerodha Kite Connect v3 API (not affiliated with Zerodha)')
         .version(VERSION, '-v, --version')
         .showHelpAfterError('(run `kite --help` for usage)')
         .configureOutput({

package/dist/safety.d.ts

@@ -76,6 +76,14 @@ export declare function confirmAction(ctx: Context, opts: ConfirmOptions): Promi
  *
  * Kite caps `tag` at 20 alphanumeric characters.
  */
+/**
+ * Prefix on every tag the CLI generates for an order it places.
+ *
+ * It lets the orderbook be filtered back to orders this tool placed — which is
+ * what `orders reconcile` (with no tag) uses to surface CLI-issued orders. Only
+ * the auto-generated tag carries it; a user-supplied `--tag` is kept verbatim.
+ */
+export declare const CLI_TAG_PREFIX = "kc";
 export declare function generateOrderTag(prefix?: string): string;
 /**
  * Build the tag actually sent to Kite, guaranteeing uniqueness even when the

package/dist/safety.js

@@ -138,7 +138,15 @@ function accountLine(ctx) {
  *
  * Kite caps `tag` at 20 alphanumeric characters.
  */
-export function generateOrderTag(prefix = 'kc') {
+/**
+ * Prefix on every tag the CLI generates for an order it places.
+ *
+ * It lets the orderbook be filtered back to orders this tool placed — which is
+ * what `orders reconcile` (with no tag) uses to surface CLI-issued orders. Only
+ * the auto-generated tag carries it; a user-supplied `--tag` is kept verbatim.
+ */
+export const CLI_TAG_PREFIX = 'kc';
+export function generateOrderTag(prefix = CLI_TAG_PREFIX) {
     const random = randomBytes(6).toString('hex');
     const stamp = Date.now().toString(36);
     return `${prefix}${stamp}${random}`.slice(0, 20);

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@pungoyal/kite-cli",
-  "version": "0.4.0",
-  "description": "Unofficial command-line interface for the Zerodha Kite Connect API — not affiliated with or endorsed by Zerodha",
+  "version": "0.5.0",
+  "description": "Unofficial, safety-first CLI (and library) for the Zerodha Kite Connect v3 API — scriptable JSON, live streaming, and confirmations on anything that moves money. Not affiliated with or endorsed by Zerodha.",
   "keywords": [
     "zerodha",
     "kite",
     "kiteconnect",
+    "kite-connect",
     "trading",
+    "trading-api",
+    "algo-trading",
     "stocks",
     "cli",
+    "terminal",
     "nse",
-    "bse"
+    "bse",
+    "nifty"
   ],
   "license": "MIT",
   "author": "Puneet Goyal",