kitecli 0.1.0__py3-none-any.whl

cli/telegram_bot.py

@@ -0,0 +1,1074 @@
+import logging
+import asyncio
+import re
+from typing import Optional
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, ReplyKeyboardMarkup, KeyboardButton, BotCommand
+from telegram.ext import (
+    ApplicationBuilder,
+    CommandHandler,
+    CallbackQueryHandler,
+    ContextTypes,
+    MessageHandler,
+    filters,
+)
+from cli.api_client import KCLIClient
+
+# Configure logging
+logger = logging.getLogger("kcli.bot")
+
+# User ID to strictly restrict access to
+def restrict_user(func):
+    """Decorator to ensure only the allowed user can access the bot commands/actions."""
+    async def wrapper(*args, **kwargs):
+        # Resolve the Update argument positionally
+        # (index 1 for method calls: self, update, context; index 0 for plain handlers: update, context)
+        update = None
+        if len(args) == 3:
+            update = args[1]
+        elif len(args) == 2:
+            update = args[0]
+
+        # Resolve the target chat_id from the bot instance (self is the first arg in method decorators)
+        bot_instance = args[0]
+        allowed_chat_id = getattr(bot_instance, "chat_id", None)
+
+        if not update or not getattr(update, "effective_chat", None):
+            return
+        chat_id = update.effective_chat.id
+        if allowed_chat_id is None or chat_id != allowed_chat_id:
+            logger.warning(f"Blocked unauthorized message/action from Chat ID: {chat_id}")
+            # Silently ignore to avoid exposing the bot to scanners
+            return
+        return await func(*args, **kwargs)
+    return wrapper
+
+
+def clean_option_symbol(symbol: str) -> str:
+    """Parses and formats option symbols into a compact format, stripping index names like NIFTY."""
+    # 1. Weekly option pattern: e.g. NIFTY2670722800PE
+    # Group 1: Symbol (e.g. NIFTY)
+    # Group 2: Year (26)
+    # Group 3: Month character (1-9, O, N, D)
+    # Group 4: Date (07)
+    # Group 5: Strike (22800)
+    # Group 6: Option Type (PE)
+    m_weekly = re.match(r"^([A-Z]+)(\d{2})([1-9ONDond])(\d{2})(\d+)(CE|PE)$", symbol)
+    if m_weekly:
+        _, year, month_char, date, strike, opt_type = m_weekly.groups()
+        months_map = {
+            "1": "Jan", "2": "Feb", "3": "Mar", "4": "Apr", "5": "May", "6": "Jun",
+            "7": "Jul", "8": "Aug", "9": "Sep", "O": "Oct", "N": "Nov", "D": "Dec"
+        }
+        month_name = months_map.get(month_char.upper(), month_char)
+        return f"{date}{month_name}{year} {strike}{opt_type}"
+
+    # 2. Monthly option pattern: e.g. NIFTY26JUL21100CE
+    # Group 1: Symbol (NIFTY)
+    # Group 2: Year (26)
+    # Group 3: Month name (JUL)
+    # Group 4: Strike (21100)
+    # Group 5: Option Type (CE)
+    m_monthly = re.match(r"^([A-Z]+)(\d{2})([A-Z]{3})(\d+)(CE|PE)$", symbol)
+    if m_monthly:
+        _, year, month_name, strike, opt_type = m_monthly.groups()
+        month_cap = month_name.capitalize()
+        return f"{month_cap}{year} {strike}{opt_type}"
+
+    return symbol
+
+
+def get_main_menu_keyboard() -> ReplyKeyboardMarkup:
+    """Returns a persistent ReplyKeyboardMarkup containing the main slash commands."""
+    keyboard = [
+        ["/positions", "/orders"],
+        ["/status", "/init"]
+    ]
+    return ReplyKeyboardMarkup(keyboard, resize_keyboard=True, is_persistent=True)
+
+
+
+class PrettyTable:
+    """ASCII table generator mimicking PrettyTable."""
+    def __init__(self) -> None:
+        self.field_names: list[str] = []
+        self.rows: list[list[str]] = []
+
+    def add_row(self, row: list[str]) -> None:
+        self.rows.append(row)
+
+    def get_string(self) -> str:
+        if not self.field_names:
+            return ""
+        # Calculate max widths
+        col_widths = [len(h) for h in self.field_names]
+        for row in self.rows:
+            for i, val in enumerate(row):
+                col_widths[i] = max(col_widths[i], len(str(val)))
+
+        # Border separator
+        border = "+" + "+".join("-" * (w + 2) for w in col_widths) + "+"
+        
+        lines = [border]
+        # Centered header row
+        header_row = "|" + "|".join(f" {h:^{col_widths[i]}} " for i, h in enumerate(self.field_names)) + "|"
+        lines.append(header_row)
+        lines.append(border)
+
+        # Left-align symbol (col 0), right-align other numeric columns
+        for row in self.rows:
+            parts = []
+            for i, val in enumerate(row):
+                val_str = str(val)
+                if i == 0:
+                    parts.append(f" {val_str:<{col_widths[i]}} ")
+                else:
+                    parts.append(f" {val_str:>{col_widths[i]}} ")
+            lines.append("|" + "|".join(parts) + "|")
+
+        lines.append(border)
+        return "\n".join(lines)
+
+
+class KCLITelegramBot:
+    """Telegram Bot wrapper for KCLIClient."""
+
+    def __init__(self, client: KCLIClient, token: str, chat_id: int) -> None:
+        self.client = client
+        self.token = token
+        self.chat_id = chat_id
+        self.app = None
+
+    async def start(self) -> None:
+        """Start the Telegram bot loop."""
+        self.app = ApplicationBuilder().token(self.token).build()
+
+        # Command handlers
+        self.app.add_handler(CommandHandler("start", self.cmd_start))
+        self.app.add_handler(CommandHandler("help", self.cmd_start))
+        self.app.add_handler(CommandHandler("positions", self.cmd_positions))
+        self.app.add_handler(CommandHandler("pos", self.cmd_positions))
+        self.app.add_handler(CommandHandler("orders", self.cmd_orders))
+        self.app.add_handler(CommandHandler("status", self.cmd_status))
+        self.app.add_handler(CommandHandler("buy", self.cmd_buy))
+        self.app.add_handler(CommandHandler("sell", self.cmd_sell))
+        self.app.add_handler(CommandHandler("modify", self.cmd_modify))
+        self.app.add_handler(CommandHandler("init", self.cmd_init))
+        self.app.add_handler(CommandHandler("token", self.cmd_token))
+        self.app.add_handler(CommandHandler("kcli", self.cmd_kcli))
+
+        # Inline button handlers
+        self.app.add_handler(CallbackQueryHandler(self.handle_callback))
+
+        # Register slash commands in the Bot command menu
+        await self.app.bot.set_my_commands([
+            BotCommand("positions", "View and manage active positions"),
+            BotCommand("orders", "View and cancel pending orders"),
+            BotCommand("status", "Check account connection status"),
+            BotCommand("init", "Initialize account sessions and get login links"),
+            BotCommand("token", "Complete login: /token <account_name> <token>"),
+            BotCommand("kcli", "Execute any kcli CLI command: /kcli <args>"),
+            BotCommand("buy", "Place buy order: /buy <symbol> <qty> [price]"),
+            BotCommand("sell", "Place sell order: /sell <symbol> <qty> [price]"),
+            BotCommand("modify", "Modify pending order: /modify <order_id> <qty> <price>"),
+        ])
+
+        logger.info("Initializing Telegram bot application...")
+        await self.app.initialize()
+        logger.info("Starting Telegram bot polling...")
+        await self.app.start()
+        await self.app.updater.start_polling()
+
+    async def stop(self) -> None:
+        """Stop the Telegram bot loop."""
+        if self.app:
+            logger.info("Stopping Telegram bot polling...")
+            await self.app.updater.stop()
+            await self.app.stop()
+            await self.app.shutdown()
+
+    @restrict_user
+    async def cmd_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Send welcome message and command list."""
+        welcome_text = (
+            "🪁 *Welcome to KiteCLI Bot!*\n\n"
+            "This bot allows you to manage positions and orders across all authenticated Zerodha accounts.\n\n"
+            "*Core Commands:*\n"
+            "• `/positions` (or `/pos`) - Display open positions & exit buttons\n"
+            "• `/orders` - View pending orders & modify/cancel options\n"
+            "• `/status` - Check account authentication status\n"
+            "• `/init` - Initialize account sessions & get login links\n"
+            "• `/token <account> <token>` - Complete manual login\n\n"
+            "*Trade Commands:*\n"
+            "• `/buy <symbol> <qty> [price]` - Place a market or limit buy order\n"
+            "• `/sell <symbol> <qty> [price]` - Place a market or limit sell order\n"
+            "• `/modify <order_id> <qty> <price>` - Modify a pending limit order's price/quantity\n\n"
+            "_Examples:_\n"
+            "• `/buy NIFTY2670722200PE 50` (Market Buy)\n"
+            "• `/buy NIFTY2670722200PE 50 85.20` (Limit Buy)"
+        )
+        await update.message.reply_text(welcome_text, reply_markup=get_main_menu_keyboard(), parse_mode="Markdown")
+
+    @restrict_user
+    async def cmd_status(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Render status check for all accounts."""
+        try:
+            status_resp = self.client.get_status()
+            accounts = status_resp.get("accounts", [])
+            if not accounts:
+                await update.message.reply_text("❌ No accounts configured in config.yaml.", reply_markup=get_main_menu_keyboard())
+                return
+
+            msg_lines = ["🔌 *Account Status:*"]
+            for acct in accounts:
+                name = acct.get("name", "Account")
+                auth = acct.get("authenticated", False)
+                status_icon = "🟢" if auth else "🔴"
+                status_lbl = "Session Active" if auth else "Not Authenticated"
+                msg_lines.append(f"{status_icon} *{name}*: {status_lbl}")
+
+            await update.message.reply_text("\n".join(msg_lines), reply_markup=get_main_menu_keyboard(), parse_mode="Markdown")
+        except Exception as exc:
+            await update.message.reply_text(f"❌ Failed to fetch status: {exc}")
+
+    @restrict_user
+    async def cmd_init(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Initialise accounts and attempt auto-login or provide manual login links."""
+        try:
+            loading_msg = await update.message.reply_text("⏳ Initialising accounts and checking session status...")
+            
+            # Auto-login or request logins
+            result = self.client.init_accounts(self.client.accounts)
+            accounts = result.get("accounts", [])
+            
+            for acct in accounts:
+                name = acct.get("name", "Account")
+                api_key = acct.get("api_key", "")
+                auto_logged_in = acct.get("auto_logged_in", False)
+                msg = acct.get("message", "")
+                login_url = acct.get("login_url", "")
+                
+                if auto_logged_in:
+                    await update.message.reply_text(
+                        f"✅ *{name}*: Session active / Auto-login successful!\n`{msg}`",
+                        reply_markup=get_main_menu_keyboard(),
+                        parse_mode="Markdown"
+                    )
+                else:
+                    # Manual login needed
+                    instruction = (
+                        f"🔑 *{name}* requires manual authentication:\n\n"
+                        f"1. [Click here to Login]({login_url})\n"
+                        f"2. Copy the `request_token` from the redirect URL.\n"
+                        f"3. Send it back to the bot by replying with:\n"
+                        f"`/token {name} <token>`"
+                    )
+                    await update.message.reply_text(
+                        instruction,
+                        reply_markup=get_main_menu_keyboard(),
+                        parse_mode="Markdown",
+                        disable_web_page_preview=True
+                    )
+            await loading_msg.delete()
+        except Exception as exc:
+            await update.message.reply_text(f"❌ Initialization failed: {exc}", reply_markup=get_main_menu_keyboard())
+
+    @restrict_user
+    async def cmd_token(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Handle request_token callback completion."""
+        args = context.args
+        if len(args) < 2:
+            await update.message.reply_text(
+                "❌ Invalid format. Please use:\n`/token <account_name_or_api_key> <request_token>`",
+                parse_mode="Markdown"
+            )
+            return
+            
+        target_name = args[0]
+        request_token = args[1]
+        
+        target_account = None
+        for acct in self.client.accounts:
+            if acct.get("name") == target_name or acct.get("api_key") == target_name:
+                target_account = acct
+                break
+                
+        if not target_account:
+            await update.message.reply_text(
+                f"❌ Account '{target_name}' not found in configuration.",
+                parse_mode="Markdown"
+            )
+            return
+            
+        api_key = target_account.get("api_key")
+        name = target_account.get("name", api_key)
+        
+        loading_msg = await update.message.reply_text(f"⏳ Completing login for *{name}*...", parse_mode="Markdown")
+        
+        try:
+            resp = self.client.complete_callback(api_key, request_token.strip())
+            await loading_msg.delete()
+            if resp.get("status") == "error":
+                await update.message.reply_text(
+                    f"❌ *{name}* authentication failed: {resp.get('message', 'Callback failed')}",
+                    parse_mode="Markdown"
+                )
+            else:
+                await update.message.reply_text(
+                    f"✅ *{name}* authenticated successfully! Session is now active.",
+                    reply_markup=get_main_menu_keyboard(),
+                    parse_mode="Markdown"
+                )
+        except Exception as exc:
+            if 'loading_msg' in locals():
+                try:
+                    await loading_msg.delete()
+                except Exception:
+                    pass
+            await update.message.reply_text(
+                f"❌ *{name}* login failed: {exc}",
+                parse_mode="Markdown"
+            )
+
+    @restrict_user
+    async def cmd_kcli(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Run a TUI-like command (e.g. 'account ZK8719 && sell NIFTY2670722200PE 50' or 'exit 1') and return output."""
+        raw_text = " ".join(context.args).strip()
+        if not raw_text:
+            await update.message.reply_text("❌ Usage: `/kcli <TUI_commands>`\nExample: `/kcli account ZK8719 && sell NIFTY2670722200PE 50`", parse_mode="Markdown")
+            return
+            
+        loading_msg = await update.message.reply_text(f"⏳ Executing kcli command: `{raw_text}`...")
+        
+        # Split commands by '&&'
+        sub_commands = [c.strip() for c in raw_text.split("&&") if c.strip()]
+        
+        selected_account_key = "ALL"
+        output_lines = []
+        
+        try:
+            for sub_cmd in sub_commands:
+                parts = [p.strip() for p in sub_cmd.split() if p.strip()]
+                if not parts:
+                    continue
+                primary = parts[0].lower()
+                
+                # 1. Account selection: account <name>
+                if primary in ("account", "acct", "a"):
+                    if len(parts) < 2:
+                        raise ValueError("Usage: account <name|all>")
+                    target_name = parts[1]
+                    if target_name.lower() in ("none", "clear", "null", "all"):
+                        selected_account_key = "ALL"
+                        output_lines.append("Account selection cleared (targeting all accounts).")
+                    else:
+                        resolved_acct = None
+                        for acct in self.client.accounts:
+                            if acct.get("name") == target_name or acct.get("api_key") == target_name:
+                                resolved_acct = acct
+                                break
+                        if not resolved_acct:
+                            raise ValueError(f"Account '{target_name}' not found.")
+                        selected_account_key = resolved_acct["api_key"]
+                        output_lines.append(f"Selected account: {resolved_acct.get('name', selected_account_key)}")
+                
+                # 2. Buy/Sell: buy/sell <symbol> <qty> [price]
+                elif primary in ("buy", "sell"):
+                    if len(parts) < 3:
+                        raise ValueError(f"Usage: {primary} <symbol> <qty> [price]")
+                    symbol = parts[1].upper()
+                    
+                    try:
+                        qty = int(parts[2])
+                    except ValueError:
+                        raise ValueError("Quantity must be an integer.")
+                        
+                    price = None
+                    order_type = "MARKET"
+                    if len(parts) >= 4:
+                        try:
+                            price = float(parts[3])
+                            order_type = "LIMIT"
+                        except ValueError:
+                            raise ValueError("Price must be a valid number.")
+                            
+                    exchange = "NFO" if len(symbol) > 6 else "NSE"
+                    
+                    # Resolve api keys
+                    api_keys = [selected_account_key] if selected_account_key != "ALL" else [a["api_key"] for a in self.client.accounts]
+                    
+                    output_lines.append(f"Placing {order_type} {primary.upper()} for {symbol} (Qty: {qty})...")
+                    res = self.client.place_order(
+                        api_keys=api_keys,
+                        tradingsymbol=symbol,
+                        exchange=exchange,
+                        transaction_type=primary.upper(),
+                        quantity=qty,
+                        order_type=order_type,
+                        price=price
+                    )
+                    for r in res.get("results", []):
+                        icon = "✅" if r.get("status") == "success" else "❌"
+                        output_lines.append(f"  {icon} {r.get('name')}: {r.get('message', 'Success')}")
+                
+                # 3. Exit: exit <symbol|id> [price]
+                elif primary == "exit":
+                    if len(parts) < 2:
+                        raise ValueError("Usage: exit <symbol|id|all> [price]")
+                    target = parts[1]
+                    
+                    price = None
+                    if len(parts) >= 3:
+                        try:
+                            price = float(parts[2])
+                        except ValueError:
+                            raise ValueError("Price must be a valid number.")
+                            
+                    # Resolve exit targets
+                    api_keys = [selected_account_key] if selected_account_key != "ALL" else [a["api_key"] for a in self.client.accounts]
+                    
+                    symbol_to_exit = None
+                    if target.isdigit():
+                        pos_id = int(target)
+                        pos_resp = self.client.get_positions(api_keys)
+                        all_positions = []
+                        for acct in pos_resp.get("accounts", []):
+                            for p in acct.get("positions", []):
+                                if p.get("quantity", 0) != 0:
+                                    all_positions.append(p)
+                                    
+                        if pos_id <= 0 or pos_id > len(all_positions):
+                            raise ValueError(f"Position ID {pos_id} not found.")
+                        symbol_to_exit = all_positions[pos_id - 1]["tradingsymbol"]
+                        api_keys = [all_positions[pos_id - 1]["api_key"]]
+                    else:
+                        symbol_to_exit = target if target.lower() != "all" else None
+                        
+                    output_lines.append(f"Exiting position: {target} (Price: {price if price else 'MARKET'})...")
+                    res = self.client.exit_positions(
+                        api_keys=api_keys,
+                        symbol=symbol_to_exit,
+                        price=price
+                    )
+                    for r in res.get("results", []):
+                        icon = "✅" if r.get("status") == "success" else "❌"
+                        output_lines.append(f"  {icon} {r.get('name')}: {r.get('message', 'Success')}")
+
+                # 4. Status
+                elif primary == "status":
+                    res = self.client.get_status()
+                    output_lines.append("🔌 Account Status:")
+                    for acct in res.get("accounts", []):
+                        icon = "🟢" if acct.get("authenticated") else "🔴"
+                        output_lines.append(f"  {icon} {acct.get('name')}: {'Active' if acct.get('authenticated') else 'Inactive'}")
+
+                # 5. Positions / Pos
+                elif primary in ("positions", "pos"):
+                    res = self.client.get_positions([selected_account_key] if selected_account_key != "ALL" else None)
+                    for acct in res.get("accounts", []):
+                        output_lines.append(f"📊 Account: {acct.get('name')} (P&L: {acct.get('total_pnl', 0.0):.2f})")
+                        positions = [p for p in acct.get("positions", []) if p.get("quantity", 0) != 0]
+                        if not positions:
+                            output_lines.append("  No open positions.")
+                        else:
+                            for p in positions:
+                                sym = clean_option_symbol(p.get("tradingsymbol"))
+                                output_lines.append(f"  • {sym} | Qty: {p.get('quantity')} | Avg: {p.get('average_price'):.2f} | LTP: {p.get('last_price'):.2f}")
+                                
+                else:
+                    raise ValueError(f"Unsupported command '{primary}' in /kcli.")
+                    
+            await loading_msg.delete()
+            final_output = "\n".join(output_lines)
+            if len(final_output) > 4000:
+                final_output = final_output[:3900] + "\n... (truncated)"
+            await update.message.reply_text(f"💻 *kcli output:*\n```\n{final_output}\n```", parse_mode="Markdown")
+            
+        except Exception as exc:
+            if 'loading_msg' in locals():
+                try:
+                    await loading_msg.delete()
+                except Exception:
+                    pass
+            await update.message.reply_text(f"❌ Execution failed: {exc}")
+
+    def _format_account_positions(self, api_key: str) -> tuple[str, list[list[InlineKeyboardButton]]]:
+        """Fetch and format positions for a specific account into a clean monospaced table and separate matching buttons."""
+        pos_resp = self.client.get_positions([api_key])
+        accounts = pos_resp.get("accounts", [])
+        if not accounts:
+            return "Account not found.", []
+
+        acct = accounts[0]
+        name = acct.get("name", "Account")
+        total_pnl = acct.get("total_pnl", 0.0)
+        positions = [p for p in acct.get("positions", []) if p.get("quantity", 0) != 0]
+
+        pnl_sign = "+" if total_pnl >= 0 else ""
+        if not positions:
+            return f"✅ No active open positions for *{name}*.", []
+
+        # Construct beautiful ASCII PrettyTable
+        table = PrettyTable()
+        table.field_names = ["Symbol", "Qty", "Avg", "LTP"]
+
+        keyboard_rows = []
+        current_row = []
+        for pos in positions:
+            sym = pos.get("tradingsymbol", "")
+            qty = pos.get("quantity", 0)
+            avg = pos.get("average_price", 0.0)
+            ltp = pos.get("last_price", 0.0)
+
+            display_sym = clean_option_symbol(sym)
+            table.add_row([display_sym, str(qty), f"{avg:.2f}", f"{ltp:.2f}"])
+
+            btn = InlineKeyboardButton(
+                display_sym,
+                callback_data=f"select_pos:{sym}:{api_key}:{qty}:{avg:.2f}:{ltp:.2f}"
+            )
+            current_row.append(btn)
+            if len(current_row) == 2:
+                keyboard_rows.append(current_row)
+                current_row = []
+
+        if current_row:
+            keyboard_rows.append(current_row)
+
+        msg_lines = [
+            f"📊 *{name}* (P&L: {pnl_sign}₹{total_pnl:.2f})",
+            f"```\n{table.get_string()}\n```",
+            "👇 _Select a position to Modify or Exit:_"
+        ]
+        return "\n".join(msg_lines), keyboard_rows
+
+    @restrict_user
+    async def cmd_positions(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Fetch and display open positions across all accounts as separate interactive tables."""
+        try:
+            api_keys = [acct["api_key"] for acct in self.client.accounts]
+            has_any = False
+            for api_key in api_keys:
+                msg_text, keyboard = self._format_account_positions(api_key)
+                if keyboard:  # Only send messages for accounts with active positions
+                    has_any = True
+                    reply_markup = InlineKeyboardMarkup(keyboard)
+                    await update.message.reply_text(msg_text, reply_markup=reply_markup, parse_mode="Markdown")
+            
+            if not has_any:
+                await update.message.reply_text("✅ No active open positions across any accounts.", reply_markup=get_main_menu_keyboard())
+        except Exception as exc:
+            await update.message.reply_text(f"❌ Error fetching positions: {exc}")
+
+    @restrict_user
+    async def cmd_orders(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Fetch and display active pending orders."""
+        try:
+            api_keys = [acct["api_key"] for acct in self.client.accounts]
+            orders_resp = self.client.get_orders(api_keys)
+            accounts_data = orders_resp.get("accounts", [])
+
+            has_any_pending = False
+            for acct in accounts_data:
+                name = acct.get("name")
+                api_key = acct.get("api_key")
+                orders = acct.get("orders", [])
+
+                # Filter pending orders
+                pending = [
+                    o for o in orders 
+                    if o.get("status") in ("OPEN", "TRIGGER PENDING", "AMO SUBMITTED")
+                ]
+
+                if not pending:
+                    continue
+
+                has_any_pending = True
+                for o in pending:
+                    order_id = o.get("order_id")
+                    sym = o.get("tradingsymbol")
+                    qty = o.get("quantity")
+                    price = o.get("price")
+                    tx_type = o.get("transaction_type")
+                    ord_type = o.get("order_type")
+                    status = o.get("status")
+
+                    msg_text = (
+                        f"⏳ *Pending Order* | `{name}`\n"
+                        f"• `{sym}`\n"
+                        f"  *ID*: `{order_id}`\n"
+                        f"  *Type*: `{tx_type}` ({ord_type}) | Qty: `{qty}`\n"
+                        f"  *Price*: `{price}` | Status: `{status}`\n"
+                    )
+
+                    keyboard = [
+                        [
+                            InlineKeyboardButton(
+                                "Cancel Order",
+                                callback_data=f"confirm_cancel:{order_id}:{api_key}:{sym}"
+                            ),
+                            InlineKeyboardButton(
+                                "Modify Info",
+                                callback_data=f"prompt_modify:{order_id}:{sym}:{qty}:{price}"
+                            )
+                        ]
+                    ]
+                    reply_markup = InlineKeyboardMarkup(keyboard)
+                    await update.message.reply_text(msg_text, reply_markup=reply_markup, parse_mode="Markdown")
+
+            if not has_any_pending:
+                await update.message.reply_text("✅ No active pending orders found.", reply_markup=get_main_menu_keyboard())
+
+        except Exception as exc:
+            await update.message.reply_text(f"❌ Error fetching orders: {exc}")
+
+    @restrict_user
+    async def cmd_buy(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Place buy order across all accounts."""
+        await self._place_order_helper("BUY", update, context)
+
+    @restrict_user
+    async def cmd_sell(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Place sell order across all accounts."""
+        await self._place_order_helper("SELL", update, context)
+
+    async def _place_order_helper(
+        self,
+        transaction_type: str,
+        update: Update,
+        context: ContextTypes.DEFAULT_TYPE
+    ) -> None:
+        """Common logic to parse and place buy/sell orders, supporting optional @account routing."""
+        args = context.args
+        if not args or len(args) < 2:
+            await update.message.reply_text(
+                f"❌ Invalid syntax. Use:\n"
+                f"`/{transaction_type.lower()} <SYMBOL> <QTY> [LIMIT_PRICE] [@ACCOUNT_NAME]`\n\n"
+                f"_Examples:_\n"
+                f"• `/{transaction_type.lower()} NIFTY2670722200PE 50` (Market, All Accounts)\n"
+                f"• `/{transaction_type.lower()} NIFTY2670722200PE 50 85.20 @ZK8719` (Limit, ZK8719 only)",
+                parse_mode="Markdown"
+            )
+            return
+
+        # Check for optional target account prefixed with '@'
+        target_account_name = None
+        for arg in args:
+            if arg.startswith("@") and len(arg) > 1:
+                target_account_name = arg[1:]
+                args = [a for a in args if a != arg]
+                break
+
+        symbol = args[0].upper()
+        try:
+            qty = int(args[1])
+        except ValueError:
+            await update.message.reply_text("❌ Quantity must be an integer.")
+            return
+
+        price = None
+        order_type = "MARKET"
+        if len(args) >= 3:
+            try:
+                price_str = args[2].lstrip("@")
+                price = float(price_str)
+                order_type = "LIMIT"
+            except ValueError:
+                await update.message.reply_text("❌ Price must be a valid number.")
+                return
+
+        # Infer exchange (Nifty/Sensex options belong to NFO/BFO, indices/equities NSE)
+        exchange = "NFO"
+        if len(symbol) <= 6:
+            exchange = "NSE"
+
+        # Resolve target account
+        target_key = "ALL"
+        display_target = "ALL authenticated accounts"
+        if target_account_name:
+            resolved_acct = None
+            for acct in self.client.accounts:
+                if acct.get("name") == target_account_name or acct.get("api_key") == target_account_name:
+                    resolved_acct = acct
+                    break
+            if not resolved_acct:
+                await update.message.reply_text(
+                    f"❌ Account '{target_account_name}' not found in configuration."
+                )
+                return
+            target_key = resolved_acct["api_key"]
+            display_target = f"account *{resolved_acct.get('name', target_key)}*"
+
+        confirm_text = (
+            f"🛒 *Confirm {transaction_type} Order*\n\n"
+            f"• *Symbol*: `{symbol}`\n"
+            f"• *Quantity*: `{qty}`\n"
+            f"• *Type*: `{order_type}`"
+        )
+        if price is not None:
+            confirm_text += f"\n• *Price*: `{price:.2f}`"
+
+        confirm_text += f"\n\nPlace this order on {display_target}?"
+
+        callback_payload = f"do_place:{transaction_type}:{symbol}:{qty}:{order_type}:{exchange}:{target_key}"
+        if price is not None:
+            callback_payload += f":{price}"
+
+        keyboard = [
+            [
+                InlineKeyboardButton("✅ Confirm Order", callback_data=callback_payload),
+                InlineKeyboardButton("❌ Cancel", callback_data="cancel_action")
+            ]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await update.message.reply_text(confirm_text, reply_markup=reply_markup, parse_mode="Markdown")
+
+    @restrict_user
+    async def cmd_modify(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Modify a pending order."""
+        args = context.args
+        if not args or len(args) < 3:
+            await update.message.reply_text(
+                "❌ Invalid syntax. Use:\n"
+                "`/modify <ORDER_ID> <NEW_QTY> <NEW_PRICE>`\n\n"
+                "_Example:_\n"
+                "`/modify 240618000123 50 82.50`",
+                parse_mode="Markdown"
+            )
+            return
+
+        order_id = args[0]
+        try:
+            qty = int(args[1])
+        except ValueError:
+            await update.message.reply_text("❌ Quantity must be an integer.")
+            return
+
+        try:
+            price = float(args[2].lstrip("@"))
+        except ValueError:
+            await update.message.reply_text("❌ Price must be a valid number.")
+            return
+
+        # Find the order across accounts to determine api_key
+        api_keys = [acct["api_key"] for acct in self.client.accounts]
+        orders_resp = self.client.get_orders(api_keys)
+        accounts_data = orders_resp.get("accounts", [])
+
+        target_api_key = None
+        acct_name = ""
+        symbol = ""
+        for acct in accounts_data:
+            for o in acct.get("orders", []):
+                if o.get("order_id") == order_id:
+                    target_api_key = acct.get("api_key")
+                    acct_name = acct.get("name", "Account")
+                    symbol = o.get("tradingsymbol", "")
+                    break
+
+        if not target_api_key:
+            await update.message.reply_text(f"❌ Order `{order_id}` was not found in active pending orders.")
+            return
+
+        confirm_text = (
+            f"🔄 *Confirm Order Modification* | `{acct_name}`\n\n"
+            f"• *Symbol*: `{symbol}`\n"
+            f"• *Order ID*: `{order_id}`\n"
+            f"• *New Quantity*: `{qty}`\n"
+            f"• *New Price*: `{price:.2f}`\n\n"
+            f"Apply this modification?"
+        )
+
+        keyboard = [
+            [
+                InlineKeyboardButton(
+                    "✅ Confirm Modify",
+                    callback_data=f"do_modify:{target_api_key}:{order_id}:{qty}:{price}"
+                ),
+                InlineKeyboardButton("❌ Cancel", callback_data="cancel_action")
+            ]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await update.message.reply_text(confirm_text, reply_markup=reply_markup, parse_mode="Markdown")
+
+    @restrict_user
+    async def handle_callback(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Handle inline button actions and confirmations."""
+        query = update.callback_query
+        await query.answer()
+
+        data = query.data.split(":")
+        action = data[0]
+
+        if action == "select_pos":
+            symbol = data[1]
+            api_key = data[2]
+            qty = int(data[3])
+            avg = float(data[4]) if len(data) > 4 else 0.0
+            ltp = float(data[5]) if len(data) > 5 else 0.0
+            
+            acct_name = "Account"
+            for acct in self.client.accounts:
+                if acct.get("api_key") == api_key:
+                    acct_name = acct.get("name", "Account")
+                    break
+            
+            msg = (
+                f"🎯 *Selected Position:* `{symbol}`\n"
+                f"• *Account:* `{acct_name}`\n"
+                f"• *Current Qty:* `{qty}`\n"
+                f"• *Average Price:* `{avg:.2f}`\n"
+                f"• *LTP:* `{ltp:.2f}`\n\n"
+                f"Choose an action:"
+            )
+            
+            keyboard = [
+                [
+                    InlineKeyboardButton("🚨 Exit Position", callback_data=f"confirm_exit_single:{symbol}:{api_key}:{qty}"),
+                    InlineKeyboardButton("➕ Add More", callback_data=f"confirm_add_more:{symbol}:{api_key}:{qty}")
+                ],
+                [
+                    InlineKeyboardButton("🔙 Back to Positions", callback_data=f"back_to_positions:{api_key}")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            await query.edit_message_text(msg, reply_markup=reply_markup, parse_mode="Markdown")
+
+        elif action == "confirm_exit_single":
+            symbol = data[1]
+            api_key = data[2]
+            qty = int(data[3])
+            
+            confirm_text = (
+                f"🚨 *Market Exit Confirmation*\n\n"
+                f"Are you sure you want to exit position `{symbol}` (Qty: `{qty}`) at market price?"
+            )
+            keyboard = [
+                [
+                    InlineKeyboardButton("✅ Confirm Market Exit", callback_data=f"do_exit_single:{symbol}:{api_key}"),
+                    InlineKeyboardButton("❌ Cancel", callback_data="cancel_action")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            await query.edit_message_reply_markup(reply_markup=reply_markup)
+
+        elif action == "do_exit_single":
+            symbol = data[1]
+            api_key = data[2]
+            await query.edit_message_text(f"⏳ Placing market exit order for `{symbol}`...")
+            try:
+                res = self.client.exit_positions([api_key], tradingsymbol=symbol)
+                res_lines = [f"📊 *Market Exit Result:* `{symbol}`"]
+                for r in res.get("results", []):
+                    name = r.get("name")
+                    status = r.get("status")
+                    msg = r.get("message", "")
+                    icon = "✅" if status == "success" else "❌"
+                    res_lines.append(f"{icon} *{name}*: {msg}")
+
+                await query.edit_message_text("\n".join(res_lines), parse_mode="Markdown")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Exit execution failed: {exc}")
+
+        elif action == "confirm_add_more":
+            symbol = data[1]
+            api_key = data[2]
+            qty = int(data[3])
+            
+            tx_type = "BUY" if qty > 0 else "SELL"
+            abs_qty = abs(qty)
+            exchange = "NFO" if len(symbol) > 6 else "NSE"
+            
+            confirm_text = (
+                f"➕ *Confirm Add More Position*\n\n"
+                f"• *Symbol*: `{symbol}`\n"
+                f"• *Current Qty*: `{qty}`\n"
+                f"• *Order*: `{tx_type}` `{abs_qty}` (Market)\n\n"
+                f"Place market order to increase position size?"
+            )
+            
+            callback_payload = f"do_place_add:{tx_type}:{symbol}:{abs_qty}:{exchange}:{api_key}"
+            keyboard = [
+                [
+                    InlineKeyboardButton("✅ Confirm Add More", callback_data=callback_payload),
+                    InlineKeyboardButton("❌ Cancel", callback_data="cancel_action")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            await query.edit_message_reply_markup(reply_markup=reply_markup)
+
+        elif action == "do_place_add":
+            tx_type = data[1]
+            symbol = data[2]
+            qty = int(data[3])
+            exchange = data[4]
+            api_key = data[5]
+            
+            await query.edit_message_text(f"⏳ Placing market order to add to `{symbol}`...")
+            try:
+                res = self.client.place_order(
+                    api_keys=[api_key],
+                    tradingsymbol=symbol,
+                    exchange=exchange,
+                    transaction_type=tx_type,
+                    quantity=qty,
+                    order_type="MARKET"
+                )
+                res_lines = [f"📊 *Order Execution Result:* `{symbol}`"]
+                for r in res.get("results", []):
+                    name = r.get("name")
+                    status = r.get("status")
+                    msg = r.get("message", "")
+                    icon = "✅" if status == "success" else "❌"
+                    res_lines.append(f"{icon} *{name}*: {msg}")
+
+                await query.edit_message_text("\n".join(res_lines), parse_mode="Markdown")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Order placement failed: {exc}")
+
+        elif action == "back_to_positions":
+            api_key = data[1]
+            await query.edit_message_text("⏳ Reloading positions...")
+            try:
+                msg_text, keyboard = self._format_account_positions(api_key)
+                reply_markup = InlineKeyboardMarkup(keyboard) if keyboard else None
+                await query.edit_message_text(msg_text, reply_markup=reply_markup, parse_mode="Markdown")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Error reloading positions: {exc}")
+
+        elif action == "confirm_exit":
+            symbol = data[1]
+            confirm_text = (
+                f"🚨 *Market Exit Confirmation*\n\n"
+                f"Are you sure you want to exit position `{symbol}` across *ALL* accounts at market price?"
+            )
+            keyboard = [
+                [
+                    InlineKeyboardButton("✅ Yes, Market Exit", callback_data=f"do_exit:{symbol}"),
+                    InlineKeyboardButton("❌ No, Keep Open", callback_data="cancel_action")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            await query.edit_message_reply_markup(reply_markup=reply_markup)
+
+        elif action == "do_exit":
+            symbol = data[1]
+            await query.edit_message_text(f"⏳ Placing market exit orders for `{symbol}`...")
+            try:
+                api_keys = [acct["api_key"] for acct in self.client.accounts]
+                res = self.client.exit_positions(api_keys, tradingsymbol=symbol)
+                
+                res_lines = [f"📊 *Market Exit Results:* `{symbol}`"]
+                for r in res.get("results", []):
+                    name = r.get("name")
+                    status = r.get("status")
+                    msg = r.get("message", "")
+                    icon = "✅" if status == "success" else "❌"
+                    res_lines.append(f"{icon} *{name}*: {msg}")
+
+                await query.edit_message_text("\n".join(res_lines), parse_mode="Markdown")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Exit execution failed: {exc}")
+
+        elif action == "confirm_cancel":
+            order_id = data[1]
+            api_key = data[2]
+            symbol = data[3]
+            confirm_text = (
+                f"🚨 *Cancel Order Confirmation*\n\n"
+                f"Cancel order `{order_id}` (`{symbol}`)?"
+            )
+            keyboard = [
+                [
+                    InlineKeyboardButton(
+                        "✅ Yes, Cancel Order",
+                        callback_data=f"do_cancel:{order_id}:{api_key}"
+                    ),
+                    InlineKeyboardButton("❌ No, Keep Pending", callback_data="cancel_action")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            await query.edit_message_reply_markup(reply_markup=reply_markup)
+
+        elif action == "do_cancel":
+            order_id = data[1]
+            api_key = data[2]
+            await query.edit_message_text(f"⏳ Sending cancellation for `{order_id}`...")
+            try:
+                res = self.client.cancel_order(api_key, order_id)
+                icon = "✅" if res.get("status") == "success" else "❌"
+                await query.edit_message_text(f"{icon} {res.get('message')}")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Cancel execution failed: {exc}")
+
+        elif action == "prompt_modify":
+            order_id = data[1]
+            sym = data[2]
+            qty = data[3]
+            price = data[4]
+            instr = (
+                f"🔄 *Modify Order `{order_id}` (`{sym}`)*\n\n"
+                f"Current: Qty `{qty}` @ Price `{price}`\n\n"
+                f"To apply modifications, please type:\n"
+                f"`/modify {order_id} <qty> <price>`"
+            )
+            await query.edit_message_text(instr, parse_mode="Markdown")
+
+        elif action == "do_place":
+            tx_type = data[1]
+            symbol = data[2]
+            qty = int(data[3])
+            ord_type = data[4]
+            exchange = data[5]
+            target_key = data[6]
+            price = float(data[7]) if len(data) > 7 else None
+
+            await query.edit_message_text(f"⏳ Placing `{ord_type}` `{tx_type}` orders for `{symbol}`...")
+            try:
+                if target_key == "ALL":
+                    api_keys = [acct["api_key"] for acct in self.client.accounts]
+                else:
+                    api_keys = [target_key]
+
+                res = self.client.place_order(
+                    api_keys=api_keys,
+                    tradingsymbol=symbol,
+                    exchange=exchange,
+                    transaction_type=tx_type,
+                    quantity=qty,
+                    order_type=ord_type,
+                    price=price
+                )
+                
+                res_lines = [f"📊 *Order Execution Results:* `{symbol}`"]
+                for r in res.get("results", []):
+                    name = r.get("name")
+                    status = r.get("status")
+                    msg = r.get("message", "")
+                    icon = "✅" if status == "success" else "❌"
+                    res_lines.append(f"{icon} *{name}*: {msg}")
+
+                await query.edit_message_text("\n".join(res_lines), parse_mode="Markdown")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Order placement failed: {exc}")
+
+        elif action == "do_modify":
+            api_key = data[1]
+            order_id = data[2]
+            qty = int(data[3])
+            price = float(data[4])
+
+            await query.edit_message_text(f"⏳ Sending modification for `{order_id}`...")
+            try:
+                res = self.client.modify_order(
+                    api_key=api_key,
+                    order_id=order_id,
+                    quantity=qty,
+                    price=price
+                )
+                icon = "✅" if res.get("status") == "success" else "❌"
+                await query.edit_message_text(f"{icon} {res.get('message')}")
+            except Exception as exc:
+                await query.edit_message_text(f"❌ Modification failed: {exc}")
+
+        elif action == "cancel_action":
+            await query.edit_message_text("❌ Action cancelled.")