@ethosagent/tools-india-broker-zerodha 0.1.0

package/dist/cli.js

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/auth.ts
+import { createHash } from "crypto";
+var KITE_SESSION_URL = "https://api.kite.trade/session/token";
+function buildLoginUrl(apiKey) {
+  return `https://kite.trade/connect/login?v=3&api_key=${apiKey}`;
+}
+function computeChecksum(apiKey, requestToken, apiSecret) {
+  return createHash("sha256").update(apiKey + requestToken + apiSecret).digest("hex");
+}
+async function exchangeToken(apiKey, apiSecret, requestToken) {
+  const checksum = computeChecksum(apiKey, requestToken, apiSecret);
+  const body = new URLSearchParams();
+  body.set("api_key", apiKey);
+  body.set("request_token", requestToken);
+  body.set("checksum", checksum);
+  const res = await fetch(KITE_SESSION_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  const json = await res.json();
+  if (json.status !== "success") {
+    throw new Error(`Token exchange failed: ${json.message ?? "unknown error"}`);
+  }
+  return json.data;
+}
+async function validateToken(apiKey, accessToken) {
+  try {
+    const res = await fetch("https://api.kite.trade/user/profile", {
+      method: "GET",
+      headers: {
+        Authorization: `token ${apiKey}:${accessToken}`,
+        "X-Kite-Version": "3"
+      }
+    });
+    if (res.status === 403) {
+      return { valid: false, expiresHint: "Token expired" };
+    }
+    const json = await res.json();
+    if (json.error_type === "TokenException") {
+      return { valid: false, expiresHint: "Token expired" };
+    }
+    if (json.status === "success" && json.data) {
+      return {
+        valid: true,
+        userId: json.data.user_id,
+        expiresHint: "tonight at midnight IST"
+      };
+    }
+    return { valid: false, expiresHint: "Unknown validation error" };
+  } catch {
+    return { valid: false, expiresHint: "Network error during validation" };
+  }
+}
+
+// src/kite-client.ts
+var KITE_BASE = "https://api.kite.trade";
+function authHeaders(creds) {
+  return {
+    Authorization: `token ${creds.apiKey}:${creds.accessToken}`,
+    "X-Kite-Version": "3",
+    "Content-Type": "application/x-www-form-urlencoded"
+  };
+}
+var KiteTokenExpiredError = class extends Error {
+  code = "TOKEN_EXPIRED";
+  constructor(message = "Kite access token expired. Renew via zerodha-broker auth.") {
+    super(message);
+    this.name = "KiteTokenExpiredError";
+  }
+};
+var KiteApiError = class extends Error {
+  constructor(message, errorType, statusCode) {
+    super(message);
+    this.errorType = errorType;
+    this.statusCode = statusCode;
+    this.name = "KiteApiError";
+  }
+  errorType;
+  statusCode;
+};
+async function kiteGet(creds, path) {
+  const res = await fetch(`${KITE_BASE}${path}`, {
+    method: "GET",
+    headers: authHeaders(creds)
+  });
+  const body = await res.json();
+  if (res.status === 403 || body.error_type === "TokenException") {
+    throw new KiteTokenExpiredError(body.message);
+  }
+  if (body.status === "error") {
+    throw new KiteApiError(
+      body.message ?? "Unknown error",
+      body.error_type ?? "Unknown",
+      res.status
+    );
+  }
+  return body.data;
+}
+async function fetchMargins(creds) {
+  return kiteGet(creds, "/user/margins");
+}
+async function fetchHoldings(creds) {
+  return kiteGet(creds, "/portfolio/holdings");
+}
+async function fetchPositions(creds) {
+  return kiteGet(creds, "/portfolio/positions");
+}
+async function fetchOrders(creds) {
+  return kiteGet(creds, "/orders");
+}
+async function placeOrder(creds, params) {
+  const variety = params.variety ?? "regular";
+  const body = new URLSearchParams();
+  body.set("exchange", params.exchange);
+  body.set("tradingsymbol", params.tradingsymbol);
+  body.set("transaction_type", params.transaction_type);
+  body.set("quantity", String(params.quantity));
+  body.set("order_type", params.order_type);
+  body.set("product", params.product);
+  body.set("validity", params.validity ?? "DAY");
+  if (params.price != null) body.set("price", String(params.price));
+  if (params.trigger_price != null) body.set("trigger_price", String(params.trigger_price));
+  const res = await fetch(`${KITE_BASE}/orders/${variety}`, {
+    method: "POST",
+    headers: authHeaders(creds),
+    body: body.toString()
+  });
+  const json = await res.json();
+  if (res.status === 403 || json.error_type === "TokenException") {
+    throw new KiteTokenExpiredError(json.message);
+  }
+  if (json.status === "error") {
+    throw new KiteApiError(
+      json.message ?? "Order placement failed",
+      json.error_type ?? "Unknown",
+      res.status
+    );
+  }
+  return json.data;
+}
+async function cancelOrder(creds, orderId, variety = "regular") {
+  const res = await fetch(`${KITE_BASE}/orders/${variety}/${orderId}`, {
+    method: "DELETE",
+    headers: authHeaders(creds)
+  });
+  const json = await res.json();
+  if (res.status === 403 || json.error_type === "TokenException") {
+    throw new KiteTokenExpiredError(json.message);
+  }
+  if (json.status === "error") {
+    throw new KiteApiError(
+      json.message ?? "Order cancellation failed",
+      json.error_type ?? "Unknown",
+      res.status
+    );
+  }
+  return json.data;
+}
+
+// src/store.ts
+import Database from "better-sqlite3";
+
+// src/schema.ts
+var SQL_CREATE_HOLDINGS_CACHE = `
+  CREATE TABLE IF NOT EXISTS holdings_cache (
+    symbol        TEXT PRIMARY KEY,
+    exchange      TEXT NOT NULL,
+    isin          TEXT,
+    quantity      INTEGER NOT NULL,
+    t1_quantity   INTEGER NOT NULL DEFAULT 0,
+    avg_price     REAL NOT NULL,
+    ltp           REAL,
+    pnl           REAL,
+    pnl_pct       REAL,
+    day_change    REAL,
+    product       TEXT NOT NULL,
+    refreshed_at  INTEGER NOT NULL
+  ) STRICT;
+`;
+var SQL_CREATE_ORDER_LOG = `
+  CREATE TABLE IF NOT EXISTS order_log (
+    id              TEXT PRIMARY KEY,
+    created_at      INTEGER NOT NULL,
+    symbol          TEXT NOT NULL,
+    exchange        TEXT NOT NULL,
+    transaction_type TEXT NOT NULL,
+    quantity        INTEGER NOT NULL,
+    order_type      TEXT NOT NULL,
+    price           REAL,
+    product         TEXT NOT NULL,
+    dry_run         INTEGER NOT NULL,
+    kite_order_id   TEXT,
+    status          TEXT NOT NULL,
+    rejection_reason TEXT,
+    agent_session   TEXT
+  ) STRICT;
+`;
+var SQL_CREATE_SYNC_META = `
+  CREATE TABLE IF NOT EXISTS sync_meta (
+    key         TEXT PRIMARY KEY,
+    fetched_at  INTEGER NOT NULL,
+    status      TEXT NOT NULL DEFAULT 'ok'
+  ) STRICT;
+`;
+function migrate(db) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SQL_CREATE_HOLDINGS_CACHE);
+  db.exec(SQL_CREATE_ORDER_LOG);
+  db.exec(SQL_CREATE_SYNC_META);
+}
+
+// src/store.ts
+var TTL = {
+  HOLDINGS: 60 * 60 * 1e3
+  // 1 hour
+};
+var ZerodhaStore = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    migrate(this.db);
+  }
+  close() {
+    this.db.close();
+  }
+  // -- Holdings cache --------------------------------------------------------
+  replaceHoldings(holdings) {
+    const now = Date.now();
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM holdings_cache").run();
+      const stmt = this.db.prepare(`
+        INSERT INTO holdings_cache
+          (symbol, exchange, isin, quantity, t1_quantity, avg_price, ltp, pnl, pnl_pct, day_change, product, refreshed_at)
+        VALUES
+          (@symbol, @exchange, @isin, @quantity, @t1Quantity, @avgPrice, @ltp, @pnl, @pnlPct, @dayChange, @product, @refreshedAt)
+      `);
+      for (const h of holdings) {
+        stmt.run({
+          symbol: h.symbol,
+          exchange: h.exchange,
+          isin: h.isin,
+          quantity: h.quantity,
+          t1Quantity: h.t1Quantity,
+          avgPrice: h.avgPrice,
+          ltp: h.ltp,
+          pnl: h.pnl,
+          pnlPct: h.pnlPct,
+          dayChange: h.dayChange,
+          product: h.product,
+          refreshedAt: h.refreshedAt
+        });
+      }
+      this.db.prepare("INSERT OR REPLACE INTO sync_meta (key, fetched_at, status) VALUES (?, ?, ?)").run("holdings", now, "ok");
+    });
+    tx();
+  }
+  getHoldings() {
+    const rows = this.db.prepare("SELECT * FROM holdings_cache").all();
+    return rows.map((r) => ({
+      symbol: r.symbol,
+      exchange: r.exchange,
+      isin: r.isin,
+      quantity: r.quantity,
+      t1Quantity: r.t1_quantity,
+      avgPrice: r.avg_price,
+      ltp: r.ltp,
+      pnl: r.pnl,
+      pnlPct: r.pnl_pct,
+      dayChange: r.day_change,
+      product: r.product,
+      refreshedAt: r.refreshed_at
+    }));
+  }
+  isStale(key, ttlMs) {
+    const row = this.db.prepare("SELECT fetched_at FROM sync_meta WHERE key = ?").get(key);
+    if (!row) return true;
+    return Date.now() - row.fetched_at > ttlMs;
+  }
+  getLastFetchedAt(key) {
+    const row = this.db.prepare("SELECT fetched_at FROM sync_meta WHERE key = ?").get(key);
+    return row?.fetched_at ?? 0;
+  }
+  setSyncMeta(key, status = "ok") {
+    this.db.prepare("INSERT OR REPLACE INTO sync_meta (key, fetched_at, status) VALUES (?, ?, ?)").run(key, Date.now(), status);
+  }
+  // -- Order audit log -------------------------------------------------------
+  logOrder(row) {
+    this.db.prepare(
+      `INSERT INTO order_log
+          (id, created_at, symbol, exchange, transaction_type, quantity, order_type, price, product, dry_run, kite_order_id, status, rejection_reason, agent_session)
+        VALUES
+          (@id, @createdAt, @symbol, @exchange, @transactionType, @quantity, @orderType, @price, @product, @dryRun, @kiteOrderId, @status, @rejectionReason, @agentSession)`
+    ).run({
+      id: row.id,
+      createdAt: row.createdAt,
+      symbol: row.symbol,
+      exchange: row.exchange,
+      transactionType: row.transaction,
+      quantity: row.quantity,
+      orderType: row.orderType,
+      price: row.price,
+      product: row.product,
+      dryRun: row.dryRun ? 1 : 0,
+      kiteOrderId: row.kiteOrderId,
+      status: row.status,
+      rejectionReason: row.rejectionReason,
+      agentSession: row.agentSession
+    });
+  }
+  getOrderLog(limit = 50) {
+    const rows = this.db.prepare("SELECT * FROM order_log ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      createdAt: r.created_at,
+      symbol: r.symbol,
+      exchange: r.exchange,
+      transaction: r.transaction_type,
+      quantity: r.quantity,
+      orderType: r.order_type,
+      price: r.price,
+      product: r.product,
+      dryRun: r.dry_run === 1,
+      kiteOrderId: r.kite_order_id,
+      status: r.status,
+      rejectionReason: r.rejection_reason,
+      agentSession: r.agent_session
+    }));
+  }
+  clean() {
+    this.db.prepare("DELETE FROM holdings_cache").run();
+    this.db.prepare("DELETE FROM order_log").run();
+    this.db.prepare("DELETE FROM sync_meta").run();
+    return { tablesCleared: ["holdings_cache", "order_log", "sync_meta"] };
+  }
+};
+
+// src/cli.ts
+function getPackageRoot() {
+  const __filename = fileURLToPath(import.meta.url);
+  return join(dirname(__filename), "..");
+}
+function getFlag(args, flag) {
+  const i = args.indexOf(flag);
+  return i !== -1 ? args[i + 1] : void 0;
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function getDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  const dbPath = process.env.ZERODHA_DB ?? `${home}/.ethos/zerodha/zerodha.db`;
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dbPath;
+}
+function secretsDir() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return `${home}/.ethos/secrets/brokers/zerodha`;
+}
+function readSecret(name) {
+  try {
+    const path = join(secretsDir(), name);
+    return readFileSync(path, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+function writeSecret(name, value) {
+  const dir = secretsDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(join(dir, name), value, { mode: 384 });
+}
+function getCredentials() {
+  const apiKey = readSecret("apiKey");
+  const accessToken = readSecret("accessToken");
+  if (!apiKey || !accessToken) {
+    console.error(
+      "Missing credentials. Store api_key and access_token in ~/.ethos/secrets/brokers/zerodha/"
+    );
+    process.exit(1);
+  }
+  return { apiKey, accessToken };
+}
+function printHelp() {
+  console.log(`zerodha-broker \u2014 Zerodha Kite Connect CLI for Ethos agents
+
+Commands:
+  auth                          Print login URL and instructions
+  auth --request-token TOKEN    Exchange request_token for access_token
+  auth status                   Check if stored access token is valid
+
+  holdings                      Print all equity holdings with P&L
+  positions                     Print open positions (intraday + overnight)
+  orders                        Print today's order book
+  margins                       Print available funds and margin utilisation
+
+  order --symbol SYM --qty N --side BUY|SELL --type MARKET|LIMIT [--price P]
+                                Simulate an order (dry-run)
+  order --confirm ...           Place a real order
+  cancel --order-id ID          Cancel a pending order
+
+  log [--limit N]               Print agent order log (default: last 20)
+  clean                         Wipe local cache and order log
+
+  version
+  help
+
+Environment:
+  ZERODHA_DB=~/.ethos/zerodha/zerodha.db  (default)
+
+Examples:
+  zerodha-broker auth
+  zerodha-broker auth --request-token abc123
+  zerodha-broker auth status
+  zerodha-broker holdings
+  zerodha-broker order --symbol RELIANCE --qty 10 --side BUY --type LIMIT --price 2980
+  zerodha-broker order --symbol RELIANCE --qty 10 --side BUY --type LIMIT --price 2980 --confirm
+`);
+}
+async function cmdAuth(args) {
+  const requestToken = getFlag(args, "--request-token");
+  if (args[1] === "status") {
+    const { apiKey: apiKey2, accessToken } = getCredentials();
+    const result = await validateToken(apiKey2, accessToken);
+    if (result.valid) {
+      console.log(`Token valid. User: ${result.userId}. Expires: ${result.expiresHint}`);
+    } else {
+      console.log(`Token expired or invalid. ${result.expiresHint}`);
+      console.log(`Run: zerodha-broker auth --request-token TOKEN`);
+    }
+    return;
+  }
+  if (requestToken) {
+    const apiKey2 = readSecret("apiKey");
+    const apiSecret = readSecret("apiSecret");
+    if (!apiKey2 || !apiSecret) {
+      console.error("Missing apiKey or apiSecret in ~/.ethos/secrets/brokers/zerodha/");
+      process.exit(1);
+    }
+    console.log("Exchanging request_token for access_token...");
+    const result = await exchangeToken(apiKey2, apiSecret, requestToken);
+    writeSecret("accessToken", result.access_token);
+    console.log(`Success! User: ${result.user_id}`);
+    console.log(`Access token stored. Valid until midnight IST.`);
+    return;
+  }
+  const apiKey = readSecret("apiKey");
+  if (!apiKey) {
+    console.error("Missing apiKey in ~/.ethos/secrets/brokers/zerodha/apiKey");
+    process.exit(1);
+  }
+  const url = buildLoginUrl(apiKey);
+  console.log(`Open this URL in your browser to log in:
+
+  ${url}
+`);
+  console.log("After login, copy the request_token from the redirect URL and run:");
+  console.log("  zerodha-broker auth --request-token TOKEN");
+}
+async function cmdHoldings() {
+  const { apiKey, accessToken } = getCredentials();
+  const holdings = await fetchHoldings({ apiKey, accessToken });
+  if (holdings.length === 0) {
+    console.log("No holdings found.");
+    return;
+  }
+  const store = new ZerodhaStore(getDbPath());
+  try {
+    const now = Date.now();
+    const rows = holdings.map((h) => ({
+      symbol: h.tradingsymbol,
+      exchange: h.exchange,
+      isin: h.isin,
+      quantity: h.quantity,
+      t1Quantity: h.t1_quantity,
+      avgPrice: h.average_price,
+      ltp: h.last_price,
+      pnl: h.pnl,
+      pnlPct: h.average_price > 0 ? Number((h.pnl / (h.quantity * h.average_price) * 100).toFixed(2)) : null,
+      dayChange: h.day_change_percentage,
+      product: h.product,
+      refreshedAt: now
+    }));
+    store.replaceHoldings(rows);
+  } finally {
+    store.close();
+  }
+  console.log("Symbol          Qty    Avg Price     LTP         P&L    P&L%");
+  console.log("\u2500".repeat(70));
+  for (const h of holdings) {
+    const pnlPct = h.average_price > 0 ? (h.pnl / (h.quantity * h.average_price) * 100).toFixed(2) : "0.00";
+    console.log(
+      `${h.tradingsymbol.padEnd(16)}${String(h.quantity).padStart(4)}  ${h.average_price.toFixed(2).padStart(10)}  ${h.last_price.toFixed(2).padStart(10)}  ${h.pnl.toFixed(2).padStart(10)}  ${pnlPct.padStart(6)}%`
+    );
+  }
+}
+async function cmdPositions() {
+  const { apiKey, accessToken } = getCredentials();
+  const positions = await fetchPositions({ apiKey, accessToken });
+  if (positions.day.length === 0 && positions.net.length === 0) {
+    console.log("No open positions.");
+    return;
+  }
+  if (positions.day.length > 0) {
+    console.log("Day positions:");
+    for (const p of positions.day) {
+      console.log(
+        `  ${p.tradingsymbol} ${p.product} qty=${p.quantity} avg=${p.average_price} ltp=${p.last_price} pnl=${p.pnl}`
+      );
+    }
+  }
+  if (positions.net.length > 0) {
+    console.log("Net positions:");
+    for (const p of positions.net) {
+      console.log(
+        `  ${p.tradingsymbol} ${p.product} qty=${p.quantity} avg=${p.average_price} ltp=${p.last_price} pnl=${p.pnl}`
+      );
+    }
+  }
+}
+async function cmdOrders() {
+  const { apiKey, accessToken } = getCredentials();
+  const orders = await fetchOrders({ apiKey, accessToken });
+  if (orders.length === 0) {
+    console.log("No orders today.");
+    return;
+  }
+  for (const o of orders) {
+    console.log(
+      `${o.order_id}  ${o.tradingsymbol}  ${o.transaction_type}  qty=${o.quantity}  type=${o.order_type}  price=${o.price}  status=${o.status}  ${o.order_timestamp}`
+    );
+  }
+}
+async function cmdMargins() {
+  const { apiKey, accessToken } = getCredentials();
+  const margins = await fetchMargins({ apiKey, accessToken });
+  const eq = margins.equity;
+  console.log(`Equity margins:`);
+  console.log(`  Net available:     INR ${eq.net}`);
+  console.log(`  Opening balance:   INR ${eq.available.opening_balance}`);
+  console.log(`  M2M unrealised:    INR ${eq.utilised.m2m_unrealised}`);
+  console.log(`  Exposure used:     INR ${eq.utilised.exposure}`);
+  console.log(`  Option premium:    INR ${eq.utilised.option_premium}`);
+  console.log(`  Equity enabled:    ${eq.enabled}`);
+}
+async function cmdOrder(args) {
+  const symbol = getFlag(args, "--symbol");
+  const qtyStr = getFlag(args, "--qty");
+  const side = getFlag(args, "--side");
+  const orderType = getFlag(args, "--type");
+  const priceStr = getFlag(args, "--price");
+  const confirm = hasFlag(args, "--confirm");
+  if (!symbol || !qtyStr || !side || !orderType) {
+    console.error("Required: --symbol, --qty, --side, --type");
+    process.exit(1);
+  }
+  const quantity = Number.parseInt(qtyStr, 10);
+  const price = priceStr ? Number.parseFloat(priceStr) : void 0;
+  const exchange = getFlag(args, "--exchange") ?? "NSE";
+  if (confirm) {
+    const { apiKey, accessToken } = getCredentials();
+    const result = await placeOrder(
+      { apiKey, accessToken },
+      {
+        exchange,
+        tradingsymbol: symbol,
+        transaction_type: side,
+        quantity,
+        order_type: orderType,
+        product: "CNC",
+        price
+      }
+    );
+    console.log(`Order placed: ${result.order_id}`);
+    const store = new ZerodhaStore(getDbPath());
+    try {
+      store.logOrder({
+        id: crypto.randomUUID(),
+        createdAt: Date.now(),
+        symbol,
+        exchange,
+        transaction: side,
+        quantity,
+        orderType,
+        price: price ?? null,
+        product: "CNC",
+        dryRun: false,
+        kiteOrderId: result.order_id,
+        status: "placed",
+        rejectionReason: null,
+        agentSession: null
+      });
+    } finally {
+      store.close();
+    }
+  } else {
+    const priceDesc = orderType === "LIMIT" && price != null ? `LIMIT ${price.toFixed(2)}` : "MARKET";
+    console.log(
+      `DRY RUN: Would place ${side} ${quantity} ${symbol} @ ${priceDesc} on ${exchange} (CNC)`
+    );
+    console.log("Add --confirm to place the order for real.");
+    const store = new ZerodhaStore(getDbPath());
+    try {
+      store.logOrder({
+        id: crypto.randomUUID(),
+        createdAt: Date.now(),
+        symbol,
+        exchange,
+        transaction: side,
+        quantity,
+        orderType,
+        price: price ?? null,
+        product: "CNC",
+        dryRun: true,
+        kiteOrderId: null,
+        status: "dry_run",
+        rejectionReason: null,
+        agentSession: null
+      });
+    } finally {
+      store.close();
+    }
+  }
+}
+async function cmdCancel(args) {
+  const orderId = getFlag(args, "--order-id");
+  if (!orderId) {
+    console.error("Required: --order-id");
+    process.exit(1);
+  }
+  const { apiKey, accessToken } = getCredentials();
+  const result = await cancelOrder({ apiKey, accessToken }, orderId);
+  console.log(`Order cancelled: ${result.order_id}`);
+}
+function cmdLog(args) {
+  const limitStr = getFlag(args, "--limit");
+  const limit = limitStr ? Number.parseInt(limitStr, 10) : 20;
+  const store = new ZerodhaStore(getDbPath());
+  try {
+    const log = store.getOrderLog(limit);
+    if (log.length === 0) {
+      console.log("No orders in log.");
+      return;
+    }
+    for (const o of log) {
+      const ts = new Date(o.createdAt).toISOString();
+      const dryTag = o.dryRun ? "[DRY]" : "[REAL]";
+      console.log(
+        `${ts}  ${dryTag}  ${o.transaction} ${o.quantity} ${o.symbol} @ ${o.orderType} ${o.price ?? "MKT"}  status=${o.status}  kite_id=${o.kiteOrderId ?? "n/a"}`
+      );
+    }
+  } finally {
+    store.close();
+  }
+}
+function cmdClean() {
+  const store = new ZerodhaStore(getDbPath());
+  try {
+    const result = store.clean();
+    console.log(`Cleared tables: ${result.tablesCleared.join(", ")}`);
+  } finally {
+    store.close();
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    printHelp();
+    return;
+  }
+  if (command === "version") {
+    const pkgPath = join(getPackageRoot(), "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    console.log(pkg.version);
+    return;
+  }
+  if (command === "auth") {
+    await cmdAuth(args);
+    return;
+  }
+  if (command === "holdings") {
+    await cmdHoldings();
+    return;
+  }
+  if (command === "positions") {
+    await cmdPositions();
+    return;
+  }
+  if (command === "orders") {
+    await cmdOrders();
+    return;
+  }
+  if (command === "margins") {
+    await cmdMargins();
+    return;
+  }
+  if (command === "order") {
+    await cmdOrder(args);
+    return;
+  }
+  if (command === "cancel") {
+    await cmdCancel(args);
+    return;
+  }
+  if (command === "log") {
+    cmdLog(args);
+    return;
+  }
+  if (command === "clean") {
+    cmdClean();
+    return;
+  }
+  console.error(`Unknown command: ${command}
+Run "zerodha-broker help" for usage.`);
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map