kitecli 0.2.1__tar.gz → 0.2.3__tar.gz

{kitecli-0.2.1 → kitecli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.2.1
+Version: 0.2.3
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT

{kitecli-0.2.1 → kitecli-0.2.3}/cli/kite_manager.py

@@ -97,27 +97,50 @@ class KiteAccountManager(BaseBrokerManager):
         """Core account initialisation (used both directly and via ABC)."""
         proxies = {"http": proxy, "https": proxy} if proxy else None
         kite = KiteConnect(api_key=api_key, proxies=proxies)
+        
+        # Increase connection pool size and timeouts to support slow proxies
+        from requests.adapters import HTTPAdapter
+        adapter = HTTPAdapter(pool_connections=100, pool_maxsize=100)
+        kite.reqsession.mount("https://", adapter)
+        kite.reqsession.mount("http://", adapter)
+        kite.timeout = 25
+
         self._clients[api_key] = kite
         self._api_secrets[api_key] = api_secret
         self._account_names[api_key] = name or api_key
         self._authenticated[api_key] = False
         self._proxies[api_key] = proxies or {}
 
+        # Monkeypatch reqsession.request to bypass proxy for all non-order endpoints
+        orig_request = kite.reqsession.request
+        def proxied_request(method, url, *args, **kwargs):
+            method_upper = method.upper()
+            url_lower = url.lower()
+            # Only apply proxies for order placement, modification, or cancellation
+            is_order_api = (
+                method_upper in ("POST", "PUT", "DELETE") and
+                ("/orders" in url_lower or "/gtt" in url_lower)
+            )
+            if not is_order_api:
+                # Remove proxies for both the individual request kwargs and session-level config
+                kwargs["proxies"] = {}
+                orig_proxies = kite.reqsession.proxies
+                kite.reqsession.proxies = {}
+                try:
+                    return orig_request(method, url, *args, **kwargs)
+                finally:
+                    kite.reqsession.proxies = orig_proxies
+            else:
+                return orig_request(method, url, *args, **kwargs)
+
+        kite.reqsession.request = proxied_request
+
         sessions = _load_sessions()
         saved_token = sessions.get(api_key)
         if saved_token:
-            logger.info("Found saved session token for '%s' (api_key=%s…). Verifying...", name, api_key[:8])
-            try:
-                kite.set_access_token(saved_token)
-                kite.profile()
-                self._authenticated[api_key] = True
-                logger.info("Successfully restored valid session for '%s' (api_key=%s…)", name, api_key[:8])
-            except Exception as exc:
-                logger.info(
-                    "Saved session token for '%s' (api_key=%s…) is invalid or expired: %s",
-                    name, api_key[:8], exc,
-                )
-                self._authenticated[api_key] = False
+            logger.debug("Found saved session token for '%s' (api_key=%s…). Assuming valid.", name, api_key[:8])
+            kite.set_access_token(saved_token)
+            self._authenticated[api_key] = True
 
         login_url = f"https://kite.zerodha.com/connect/login?v=3&api_key={api_key}"
         logger.info("Initialized account '%s' (api_key=%s…)", name, api_key[:8])
@@ -374,16 +397,21 @@ class KiteAccountManager(BaseBrokerManager):
         # Build a requests.Session and apply the per-account proxy so that
         # login and 2FA calls also flow through the proxy (not just KiteConnect SDK calls).
         session = http_requests.Session()
-        account_proxies = self._proxies.get(api_key, {})
-        if account_proxies:
-            session.proxies.update(account_proxies)
-            logger.info("auto_login: using proxy for %s (api_key=%s…)", user_id, api_key[:8])
+        from requests.adapters import HTTPAdapter
+        adapter = HTTPAdapter(pool_connections=20, pool_maxsize=20)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+
+        # Zerodha login does not enforce whitelisting, direct is faster and more reliable
+        # session.proxies.update(account_proxies)
+        # logger.info("auto_login: using proxy for %s (api_key=%s…)", user_id, api_key[:8])
 
         try:
             # Step 1: Login with user_id + password
             login_resp = session.post(
                 "https://kite.zerodha.com/api/login",
                 data={"user_id": user_id, "password": password},
+                timeout=25,
             )
             login_data = login_resp.json()
 
@@ -411,6 +439,7 @@ class KiteAccountManager(BaseBrokerManager):
                     "user_id": user_id,
                     "twofa_type": "totp",
                 },
+                timeout=25,
             )
             twofa_data = twofa_resp.json()
 
@@ -434,19 +463,8 @@ class KiteAccountManager(BaseBrokerManager):
 
             for hop in range(1, 11):
                 logger.info("Auto-login hop %d: %s", hop, current_url)
-                try:
-                    resp = session.get(current_url, allow_redirects=False)
-                except http_requests.exceptions.RequestException as exc:
-                    logger.warning("Network error/unreachable during redirect hop %d: %s", hop, exc)
-                    # Check if the url itself contained the token before network error
-                    parsed = urlparse(current_url)
-                    query_params = parse_qs(parsed.query)
-                    token = query_params.get("request_token", [None])[0]
-                    if token:
-                        request_token = token
-                    break
 
-                # Check if current_url already contains the request_token
+                # Check if current_url already contains the request_token BEFORE requesting it
                 parsed = urlparse(current_url)
                 query_params = parse_qs(parsed.query)
                 token = query_params.get("request_token", [None])[0]
@@ -454,6 +472,12 @@ class KiteAccountManager(BaseBrokerManager):
                     request_token = token
                     break
 
+                try:
+                    resp = session.get(current_url, allow_redirects=False, timeout=25)
+                except http_requests.exceptions.RequestException as exc:
+                    logger.warning("Network error/unreachable during redirect hop %d: %s", hop, exc)
+                    break
+
                 location = resp.headers.get("Location")
                 if not location:
                     break
@@ -465,21 +489,14 @@ class KiteAccountManager(BaseBrokerManager):
 
                 current_url = location
 
-                # Check if target redirect URL contains the request_token
-                parsed = urlparse(current_url)
-                query_params = parse_qs(parsed.query)
-                token = query_params.get("request_token", [None])[0]
-                if token:
-                    request_token = token
-                    break
-
                 # If target URL is not a Zerodha domain (e.g. localhost or client app domain),
                 # do not actually request it (it may not be reachable or could trigger external side-effects),
                 # and we've already checked if it has the request_token.
                 parsed_loc = urlparse(current_url)
                 if parsed_loc.netloc and not parsed_loc.netloc.endswith(".zerodha.com") and "zerodha.com" not in parsed_loc.netloc:
                     logger.info("Reached non-Zerodha redirect target: %s", current_url)
-                    break
+                    # We will extract the token at the start of the next iteration
+                    pass
 
             if not request_token:
                 logger.error("Could not extract request_token from redirect chain for %s", user_id)
@@ -1064,38 +1081,7 @@ class KiteAccountManager(BaseBrokerManager):
                     except Exception as exc:
                         logger.warning("Kite indices fetch failed for api_key=%s…: %s", api_key[:8], exc)
 
-        # 2. Fallback to Yahoo Finance chart API (in parallel)
-        try:
-            logger.info("Fetching indices from Yahoo Finance fallback...")
-            import requests as http_requests
-            headers = {"User-Agent": "Mozilla/5.0"}
-            from concurrent.futures import ThreadPoolExecutor
-
-            symbols = {
-                "nifty": "^NSEI",
-                "sensex": "^BSESN",
-                "vix": "^INDIAVIX",
-            }
-
-            def fetch_symbol_price(item):
-                name, code = item
-                url = f"https://query1.finance.yahoo.com/v8/finance/chart/{code}?interval=1m&range=1d"
-                resp = http_requests.get(url, headers=headers, timeout=5)
-                price = resp.json()["chart"]["result"][0]["meta"]["regularMarketPrice"]
-                return name, float(price)
-
-            with ThreadPoolExecutor(max_workers=3) as executor:
-                results = dict(executor.map(fetch_symbol_price, symbols.items()))
-
-            return {
-                "status": "success",
-                "nifty": results["nifty"],
-                "sensex": results["sensex"],
-                "vix": results["vix"],
-            }
-        except Exception as exc:
-            logger.error("Yahoo Finance fallback failed: %s", exc)
-            return {"status": "error", "message": f"Kite call had insufficient permission, and Yahoo fallback failed: {exc}"}
+        return {"status": "error", "message": "All authenticated Zerodha account indices fetches failed."}
 
     def get_ltp_and_tokens(self, api_key: str, symbols: list[str]) -> dict:
         """Fetch LTP and instrument tokens for the given symbols using Zerodha ltp()."""

{kitecli-0.2.1 → kitecli-0.2.3}/cli/kotak_manager.py

@@ -148,6 +148,9 @@ class KotakAccountManager(BaseBrokerManager):
         self._authenticated: dict[str, bool] = {}
         # consumer_key → stored credentials for re-auth
         self._credentials: dict[str, dict] = {}
+        import threading as _threading
+        self._auth_lock = _threading.Lock()
+        self._last_login_time: dict[str, float] = {}
 
     # ── account lifecycle ──────────────────────────────────────────────────────
 
@@ -255,7 +258,10 @@ class KotakAccountManager(BaseBrokerManager):
             def _do_req(h):
                 req_kwargs = {}
                 if _proxies:
-                    req_kwargs["proxies"] = _proxies
+                    # Kotak Neo static IP whitelisting is only enforced on order APIs
+                    url_lower = u_with_params.lower()
+                    if "/order/" in url_lower and any(x in url_lower for x in ["/place", "/modify", "/cancel"]):
+                        req_kwargs["proxies"] = _proxies
 
                 logger.debug("Kotak REST [%s] requesting: %s", method, u_with_params)
                 logger.debug("Kotak REST headers: %s", {k: v[:15] + '...' if len(str(v)) > 15 else v for k, v in h.items()})
@@ -355,100 +361,91 @@ class KotakAccountManager(BaseBrokerManager):
         sessions = _load_sessions()
         saved_session = sessions.get(f"kotak:{consumer_key}")
         if saved_session and isinstance(saved_session, dict):
-            logger.info(
-                "Found saved Kotak session for '%s' (key=%s…). Verifying...",
-                name, consumer_key[:8],
-            )
-            try:
-                client.configuration.edit_token = saved_session.get("edit_token")
-                client.configuration.edit_sid = saved_session.get("edit_sid")
-                client.configuration.edit_rid = saved_session.get("edit_rid")
-                client.configuration.serverId = saved_session.get("serverId")
-                client.configuration.data_center = saved_session.get("data_center")
-                client.configuration.base_url = saved_session.get("base_url")
-
-                # Verify token liveness
-                limits_resp = client.limits()
-                _check_neo_error(limits_resp)
-                self._authenticated[consumer_key] = True
-                logger.info(
-                    "Restored valid Kotak session for '%s' (key=%s…)", name, consumer_key[:8]
-                )
-            except Exception as exc:
-                logger.info(
-                    "Saved Kotak token for '%s' (key=%s…) expired: %s. Will attempt auto-login.",
-                    name, consumer_key[:8], exc,
-                )
-                self._authenticated[consumer_key] = False
+            logger.debug("Found saved Kotak session for '%s' (key=%s…). Assuming valid.", name, consumer_key[:8])
+            client.configuration.edit_token = saved_session.get("edit_token")
+            client.configuration.edit_sid = saved_session.get("edit_sid")
+            client.configuration.edit_rid = saved_session.get("edit_rid")
+            client.configuration.serverId = saved_session.get("serverId")
+            client.configuration.data_center = saved_session.get("data_center")
+            client.configuration.base_url = saved_session.get("base_url")
+            
+            self._authenticated[consumer_key] = True
 
         if not self._authenticated.get(consumer_key):
-            logger.info("No valid Kotak session found for '%s' (key=%s…). Attempting auto-login...", name, consumer_key[:8])
-            try:
-                self.auto_login(consumer_key)
-            except Exception as e:
-                logger.error("Auto-login failed for Kotak account '%s': %s", name, e)
+            logger.debug("No valid Kotak session found for '%s' (key=%s…).", name, consumer_key[:8])
 
         return ""  # no login URL for Kotak
 
     def auto_login(self, account_key: str, **_kwargs) -> bool:
         """Perform TOTP-based auto-login for the Kotak account."""
-        creds = self._credentials.get(account_key, {})
-        totp_secret = creds.get("totp_secret", "")
-        mobile_number = creds.get("mobile_number", "")
-        mpin = creds.get("mpin", "")
-        ucc = creds.get("ucc", "")
-
-        if not (mobile_number and ucc and mpin and totp_secret):
-            logger.warning(
-                "Kotak auto-login skipped for key=%s…: incomplete credentials",
-                account_key[:8],
-            )
-            return False
-
-        client = self._clients.get(account_key)
-        if not client:
-            return False
+        import time
+        with self._auth_lock:
+            # Debounce: if we just logged in within the last 15 seconds, skip re-login.
+            # This prevents concurrent threads from hammering the login endpoint when
+            # multiple requests see a 100008 (session expired) error simultaneously.
+            last_login = self._last_login_time.get(account_key, 0.0)
+            if time.time() - last_login < 15.0:
+                logger.info("Kotak auto-login skipped for key=%s… (debounced)", account_key[:8])
+                return True
+
+            creds = self._credentials.get(account_key, {})
+            totp_secret = creds.get("totp_secret", "")
+            mobile_number = creds.get("mobile_number", "")
+            mpin = creds.get("mpin", "")
+            ucc = creds.get("ucc", "")
+
+            if not (mobile_number and ucc and mpin and totp_secret):
+                logger.warning(
+                    "Kotak auto-login skipped for key=%s…: incomplete credentials",
+                    account_key[:8],
+                )
+                return False
 
-        try:
-            totp_code = pyotp.TOTP(totp_secret).now()
-            logger.info("Kotak login: sending login request for key=%s…", account_key[:8])
-
-            # Step 1: Initiate login
-            login_resp = client.totp_login(
-                mobile_number=mobile_number,
-                ucc=ucc,
-                totp=totp_code,
-            )
-            logger.debug("Kotak login resp: %s", login_resp)
-            if isinstance(login_resp, dict) and "Error" in login_resp:
-                raise RuntimeError(f"TOTP login failed: {login_resp}")
-
-            # Step 2: 2FA validation with MPIN
-            session_resp = client.totp_validate(mpin=mpin)
-            logger.debug("Kotak 2FA resp: %s", session_resp)
-            if isinstance(session_resp, dict) and "Error" in session_resp:
-                raise RuntimeError(f"MPIN validation failed: {session_resp}")
-
-            # Persist token
-            conf = client.configuration
-            if getattr(conf, "edit_token", None):
-                session_data = {
-                    "edit_token": conf.edit_token,
-                    "edit_sid": conf.edit_sid,
-                    "edit_rid": conf.edit_rid,
-                    "serverId": conf.serverId,
-                    "data_center": conf.data_center,
-                    "base_url": conf.base_url,
-                }
-                _save_session(f"kotak:{account_key}", session_data)
+            client = self._clients.get(account_key)
+            if not client:
+                return False
 
-            self._authenticated[account_key] = True
-            logger.info("Kotak auto-login successful for key=%s…", account_key[:8])
-            return True
+            try:
+                totp_code = pyotp.TOTP(totp_secret).now()
+                logger.info("Kotak login: sending login request for key=%s…", account_key[:8])
+
+                # Step 1: Initiate login
+                login_resp = client.totp_login(
+                    mobile_number=mobile_number,
+                    ucc=ucc,
+                    totp=totp_code,
+                )
+                logger.debug("Kotak login resp: %s", login_resp)
+                if isinstance(login_resp, dict) and "Error" in login_resp:
+                    raise RuntimeError(f"TOTP login failed: {login_resp}")
+
+                # Step 2: 2FA validation with MPIN
+                session_resp = client.totp_validate(mpin=mpin)
+                logger.debug("Kotak 2FA resp: %s", session_resp)
+                if isinstance(session_resp, dict) and "Error" in session_resp:
+                    raise RuntimeError(f"MPIN validation failed: {session_resp}")
+
+                # Persist token
+                conf = client.configuration
+                if getattr(conf, "edit_token", None):
+                    session_data = {
+                        "edit_token": conf.edit_token,
+                        "edit_sid": conf.edit_sid,
+                        "edit_rid": conf.edit_rid,
+                        "serverId": conf.serverId,
+                        "data_center": conf.data_center,
+                        "base_url": conf.base_url,
+                    }
+                    _save_session(f"kotak:{account_key}", session_data)
+
+                self._authenticated[account_key] = True
+                self._last_login_time[account_key] = time.time()
+                logger.info("Kotak auto-login successful for key=%s…", account_key[:8])
+                return True
 
-        except Exception as exc:
-            logger.error(
-                "Kotak auto-login failed for key=%s…: %s", account_key[:8], exc, exc_info=True
+            except Exception as exc:
+                logger.error(
+                    "Kotak auto-login failed for key=%s…: %s", account_key[:8], exc, exc_info=True
             )
             self._authenticated[account_key] = False
             return False

{kitecli-0.2.1 → kitecli-0.2.3}/cli/live_session.py

@@ -386,6 +386,10 @@ class KCLILiveSession:
             "divider": "bg:#21262d fg:#30363d",
             "divider.dragging": "bg:#0969da fg:#ffffff bold",
             "market_indices": "bg:#161b22",
+            "tab_bar": "bg:#161b22",
+            "tab.active": "bg:#1f6feb fg:#ffffff bold",
+            "tab.inactive": "bg:#21262d fg:#8b949e",
+            "tab.separator": "fg:#30363d",
             # Quick action bar
             "quickaction": "bg:#161b22 fg:#8b949e",
             "quickaction.hint": "bg:#161b22 fg:#484f58 italic",
@@ -946,6 +950,62 @@ class KCLILiveSession:
 
         return [(status_style, status_label, _header_click_handler)]
 
+    def _get_tab_bar_text(self):
+        """Build clickable, styled text fragments for the info pane tabs."""
+        def make_click_handler(mode):
+            def handler(*args, **kwargs):
+                from prompt_toolkit.mouse_events import MouseEventType
+                mouse_event = None
+                if len(args) == 2:
+                    mouse_event = args[1]
+                elif len(args) == 1:
+                    mouse_event = args[0]
+                
+                if mouse_event and mouse_event.event_type == MouseEventType.MOUSE_UP:
+                    self.info_mode = mode
+                    self._update_info_buffer()
+                    if hasattr(self, "app") and self.app:
+                        self.app.invalidate()
+            return handler
+
+        fragments = []
+        
+        # Tiny spacing for visual margin
+        fragments.append(("", " "))
+        
+        # Tab 1: Pending
+        fragments.append((
+            "class:tab.active" if self.info_mode == "orders_pending" else "class:tab.inactive",
+            " Pending ",
+            make_click_handler("orders_pending")
+        ))
+        fragments.append(("", " "))
+        
+        # Tab 2: Executed
+        fragments.append((
+            "class:tab.active" if self.info_mode == "orders_executed" else "class:tab.inactive",
+            " Executed ",
+            make_click_handler("orders_executed")
+        ))
+        fragments.append(("", " "))
+        
+        # Tab 3: OC (Option Chain)
+        fragments.append((
+            "class:tab.active" if self.info_mode == "oc" else "class:tab.inactive",
+            " OC ",
+            make_click_handler("oc")
+        ))
+        fragments.append(("", " "))
+        
+        # Tab 4: Advisor
+        fragments.append((
+            "class:tab.active" if self.info_mode == "advisor" else "class:tab.inactive",
+            " Advisor ",
+            make_click_handler("advisor")
+        ))
+        
+        return fragments
+
     async def reconnect_websockets(self) -> None:
         """Close existing WebSocket connections and start fresh ones, updating the UI."""
         self.log_message("[#58a6ff]Closing existing WebSocket connections...[/#]")
@@ -983,72 +1043,84 @@ class KCLILiveSession:
         self.log_message("Running token diagnostics...")
         statuses: dict[str, str] = {}
         any_bad = False
-        for acct in self.accounts:
+
+        async def diagnose_account(acct):
             api_key = acct.get("api_key")
+            name = acct.get("name", api_key)
             if not api_key:
-                continue
+                return api_key, "no_token", name, "", acct, [], False
+
+            logs = []
+            is_bad = False
+            broker = acct.get("broker", "zerodha").lower()
+            
+            # Fast path for Zerodha: try WebSocket auth first
+            if broker == "zerodha":
+                access_token = self.client.get_access_token(api_key)
+                if not access_token:
+                    logs.append(f"[#ff8700]⚠ No token:[/#] @{name} — login required (run 'kcli init').")
+                    return api_key, "no_token", name, "no access token", acct, logs, True
+                
+                ws_status, ws_detail = await self._run_api_call(
+                    probe_ws_auth, api_key, access_token, None
+                )
+                
+                if ws_status == "ok":
+                    logs.append(f"[#00ff00]✓ Streaming OK:[/#] @{name}")
+                    return api_key, "valid", name, "", acct, logs, False
+                elif ws_status == "proxy_blocked":
+                    logs.append(f"[#ff8700]⚠ Proxy blocked streaming:[/#] @{name} — proxy refused the WebSocket tunnel ({ws_detail}).")
+                    return api_key, "proxy_blocked", name, ws_detail, acct, logs, True
+            
+            # If we are here, either it's Kotak, or Zerodha WS failed. 
+            # Fallback to the full REST check_token to find out exactly why.
             try:
                 result = await self._run_api_call(self.client.check_token, api_key)
             except Exception as exc:
-                result = {"name": acct.get("name", api_key), "status": "error",
-                          "detail": str(exc)}
+                result = {"name": name, "status": "error", "detail": str(exc)}
+            
             status = result.get("status", "error")
-            statuses[api_key] = status
-            name = result.get("name", api_key)
             detail = result.get("detail", "")
+            
             if status == "valid":
-                broker = acct.get("broker", "zerodha").lower()
                 if broker != "zerodha":
-                    # Non-Zerodha accounts (e.g. Kotak) use their own WebSocket
-                    # feed — do not probe ws.kite.trade with a non-Zerodha token.
-                    self.log_message(f"[#00ff00]✓ Token OK:[/#] @{name}")
-                elif broker == "zerodha":
-                    # REST works, but that does NOT guarantee streaming works: the
-                    # WebSocket can still reject this token with 403 "Authentication
-                    # failed" (per api_key/app — e.g. no active streaming
-                    # subscription). Probe the actual WS handshake so we only start
-                    # tickers that will succeed and avoid a 403 reconnect storm.
-                    access_token = self.client.get_access_token(api_key)
-                    proxy_str = acct.get("proxy")
-                    ws_status, ws_detail = await self._run_api_call(
-                        probe_ws_auth, api_key, access_token, proxy_str
+                    logs.append(f"[#00ff00]✓ Token OK:[/#] @{name}")
+                else:
+                    # Zerodha REST is valid, but we already know WS failed from the fast-path above!
+                    is_bad = True
+                    status = "stream_forbidden"
+                    logs.append(
+                        f"[#ff0000]✗ Streaming rejected:[/#] @{name} — "
+                        f"WebSocket auth failed. REST works, so the "
+                        f"token is valid but this api_key lacks streaming access. "
+                        f"Check the app's subscription on the Kite Connect dashboard."
                     )
-                    if ws_status == "ok":
-                        self.log_message(f"[#00ff00]✓ Streaming OK:[/#] @{name}")
-                    elif ws_status == "auth_failed":
-                        any_bad = True
-                        statuses[api_key] = "stream_forbidden"
-                        self.log_message(
-                            f"[#ff0000]✗ Streaming rejected:[/#] @{name} — "
-                            f"WebSocket auth failed ({ws_detail}). REST works, so the "
-                            f"token is valid but this api_key lacks streaming access. "
-                            f"Check the app's subscription on the Kite Connect dashboard."
-                        )
-                    elif ws_status == "proxy_blocked":
-                        any_bad = True
-                        statuses[api_key] = "proxy_blocked"
-                        self.log_message(
-                            f"[#ff8700]⚠ Proxy blocked streaming:[/#] @{name} — "
-                            f"proxy refused the WebSocket tunnel ({ws_detail})."
-                        )
-                    else:
-                        # Inconclusive probe — let the ticker try anyway.
-                        self.log_message(
-                            f"[#ff8700]⚠ Streaming check inconclusive:[/#] @{name} "
-                            f"({ws_detail}). Will attempt to connect."
-                        )
             elif status == "no_token":
-                any_bad = True
-                self.log_message(f"[#ff8700]⚠ No token:[/#] @{name} — login required (run 'kcli init').")
+                is_bad = True
+                logs.append(f"[#ff8700]⚠ No token:[/#] @{name} — login required (run 'kcli init').")
             elif status == "expired":
-                any_bad = True
-                self.log_message(f"[#ff8700]⚠ Token expired:[/#] @{name} — re-login (run 'kcli init'). {detail}")
+                is_bad = True
+                logs.append(f"[#ff8700]⚠ Token expired:[/#] @{name} — re-login (run 'kcli init'). {detail}")
             elif status == "forbidden":
-                any_bad = True
-                self.log_message(f"[#ff0000]✗ Forbidden:[/#] @{name} — token rejected / no streaming entitlement. {detail}")
+                is_bad = True
+                logs.append(f"[#ff0000]✗ Forbidden:[/#] @{name} — token rejected / no streaming entitlement. {detail}")
             else:
+                is_bad = True
+                logs.append(f"[#ff0000]✗ Token check failed:[/#] @{name} — {detail}")
+
+            return api_key, status, name, detail, acct, logs, is_bad
+
+        tasks = [diagnose_account(acct) for acct in self.accounts]
+        results = await asyncio.gather(*tasks)
+
+        for api_key, status, name, detail, acct, logs, is_bad in results:
+            if not api_key:
+                continue
+            statuses[api_key] = status
+            for log_msg in logs:
+                self.log_message(log_msg)
+            if is_bad:
                 any_bad = True
-                self.log_message(f"[#ff0000]✗ Token check failed:[/#] @{name} — {detail}")
 
         if any_bad:
             self.log_message(
@@ -1090,15 +1162,16 @@ class KCLILiveSession:
     async def _initial_fetch_and_connect(self) -> None:
         """Initial fetch of data and connect all WebSockets."""
         self.log_message("Initializing connections and fetching data...")
+        
+        # Fire off REST data fetch in the background so it doesn't block WebSockets
+        if hasattr(self, "app") and self.app and self.app.loop:
+            asyncio.run_coroutine_threadsafe(self._trigger_immediate_refresh(), self.app.loop)
+        
         try:
-            await self._trigger_immediate_refresh()
-        except Exception as exc:
-            self.log_message(f"[#ff0000]Initial fetch failed:[/#] {exc}")
-
-        # Diagnose token validity up front. The same api_key/access_token pair is
-        # used for the WebSocket ticker, so a REST 403/expired here explains the
-        # "1006 / 403 Forbidden" handshake failures.
-        token_statuses = await self._diagnose_tokens()
+            token_statuses = await self._diagnose_tokens()
+        except Exception as e:
+            self.log_message(f"[#ff0000]Initial task failed:[/#] {e}")
+            token_statuses = {}
 
         # Choose the primary streaming account (used for index + option-chain
         # streaming). Index/OC ticks are subscribed only on this account.
@@ -1115,7 +1188,7 @@ class KCLILiveSession:
             )
 
         # Connect WebSockets for accounts that support it (Zerodha and Kotak).
-        for acct in self.accounts:
+        for idx, acct in enumerate(self.accounts):
             api_key = acct.get("api_key")
             broker = acct.get("broker", "zerodha").lower()
             access_token = self.client.get_access_token(api_key)
@@ -1128,6 +1201,9 @@ class KCLILiveSession:
                 )
                 continue
 
+            if idx > 0:
+                await asyncio.sleep(0.2)
+
             if api_key and (access_token or broker == "kotak"):
                 try:
                     if broker == "kotak":
@@ -1152,10 +1228,10 @@ class KCLILiveSession:
                     ticker.on_close = self._make_on_close(api_key)
                     ticker.on_error = self._make_on_error(api_key)
 
-                    # Parse proxy if configured for this account
+                    # Parse proxy if configured for this account (Zerodha WS does not require IP whitelisting, direct is faster)
                     proxy_str = acct.get("proxy")
                     proxy_dict = None
-                    if proxy_str:
+                    if broker != "zerodha" and proxy_str:
                         from urllib.parse import urlparse
                         try:
                             p_str = proxy_str if "://" in proxy_str else f"http://{proxy_str}"
@@ -4021,6 +4097,18 @@ class KCLILiveSession:
             get_vertical_scroll=lambda win: self._info_control.buffer.document.cursor_position_row,
         )
 
+        # Define tab bar control and window for the info pane
+        self.tab_bar_control = FormattedTextControl(
+            text=self._get_tab_bar_text,
+            focusable=False,
+        )
+        self.tab_bar_window = Window(
+            content=self.tab_bar_control,
+            height=1,
+            wrap_lines=False,
+            style="class:tab_bar",
+        )
+
         def make_scroll_handler(window, control):
             original_handler = control.mouse_handler
             def scroll_mouse_handler(mouse_event):
@@ -4136,12 +4224,11 @@ class KCLILiveSession:
 
         @kb.add("tab")
         def _tab(event):
-            """Cycle focus: input -> positions -> logs -> info pane -> input."""
+            """Cycle focus: input -> positions -> info pane -> input."""
             cur = event.app.layout.current_control
             cycle = [
                 self.input_field.control,
                 self.positions_control,
-                self._logs_control,
                 self._info_control,
             ]
             try:
@@ -4151,26 +4238,34 @@ class KCLILiveSession:
                 nxt = self.input_field.control
             event.app.layout.focus(nxt)
 
-        # F1/F2/F3 — switch info pane content
+        # Ctrl+1/2/3/4 & F1-F4 — switch info pane content
+        @kb.add("c-1")
         @kb.add("f1")
-        def _f1(event):
+        def _c1(event):
             self.info_mode = "orders_pending"
             self._update_info_buffer()
+            event.app.invalidate()
 
+        @kb.add("c-2")
         @kb.add("f2")
-        def _f2(event):
+        def _c2(event):
             self.info_mode = "orders_executed"
             self._update_info_buffer()
+            event.app.invalidate()
 
+        @kb.add("c-3")
         @kb.add("f3")
-        def _f3(event):
+        def _c3(event):
             self.info_mode = "oc"
             self._update_info_buffer()
+            event.app.invalidate()
 
+        @kb.add("c-4")
         @kb.add("f4")
-        def _f4(event):
+        def _c4(event):
             self.info_mode = "advisor"
             self._update_info_buffer()
+            event.app.invalidate()
 
         # Ctrl+Left/Right — adjust left/right pane split
         @kb.add("c-left")
@@ -4183,17 +4278,6 @@ class KCLILiveSession:
             self.left_width_pct = min(80, self.left_width_pct + 5)
             event.app.invalidate()
 
-        # Ctrl+Up/Down — adjust log pane height within left half
-        @kb.add("c-up")
-        def _shrink_log(event):
-            self.log_height_lines = max(4, self.log_height_lines - 2)
-            event.app.invalidate()
-
-        @kb.add("c-down")
-        def _grow_log(event):
-            self.log_height_lines = min(30, self.log_height_lines + 2)
-            event.app.invalidate()
-
         # Build dividers
         self.vertical_divider = Window(
             content=FormattedTextControl(
@@ -4204,15 +4288,6 @@ class KCLILiveSession:
             style="class:divider",
         )
 
-        self.horizontal_divider = Window(
-            content=FormattedTextControl(
-                text="━" * 250,
-                focusable=False,
-            ),
-            height=1,
-            style="class:divider",
-        )
-
         # Divider mouse handlers
         def v_divider_mouse_handler(mouse_event):
             from prompt_toolkit.mouse_events import MouseEventType
@@ -4221,15 +4296,7 @@ class KCLILiveSession:
                 self.vertical_divider.style = "class:divider.dragging"
                 self.app.invalidate()
 
-        def h_divider_mouse_handler(mouse_event):
-            from prompt_toolkit.mouse_events import MouseEventType
-            if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
-                self.dragging_horizontal = True
-                self.horizontal_divider.style = "class:divider.dragging"
-                self.app.invalidate()
-
         self.vertical_divider.content.mouse_handler = v_divider_mouse_handler
-        self.horizontal_divider.content.mouse_handler = h_divider_mouse_handler
 
         # Monkey-patch MouseHandlers.__init__ to wrap with DragInterceptDict
         original_init = MouseHandlers.__init__
@@ -4240,32 +4307,27 @@ class KCLILiveSession:
 
         # ── Dynamic Layout ─────────────────────────────────────────
         # DynamicContainer rebuilds the body on each render using current
-        # self.left_width_pct and self.log_height_lines values.
+        # self.left_width_pct value.
         def _build_body():
             self._update_positions_display()
             lw = self.left_width_pct           # left weight (20-80)
             rw = 100 - lw                      # right weight
 
             return VSplit([
-                # ── LEFT half: Positions (scrollable) + Logs (scrollable) ──
-                HSplit([
-                    Frame(
-                        title="Active Positions (Live Ticks) [Tab: focus]",
-                        body=self.positions_window,
-                        style=self._get_frame_style(self.positions_window),
-                    ),
-                    self.horizontal_divider,
-                    Frame(
-                        title="Status Logs [Tab: focus] [Ctrl+↑↓: resize]",
-                        body=self.logs_window,
-                        style=self._get_frame_style(self.logs_window),
-                    ),
-                ], width=D(weight=lw)),
+                # ── LEFT half: Positions (scrollable) ──
+                Frame(
+                    title="Active Positions (Live Ticks) [Tab: focus]",
+                    body=self.positions_window,
+                    style=self._get_frame_style(self.positions_window),
+                    width=D(weight=lw),
+                ),
                 self.vertical_divider,
-                # ── RIGHT half: Info Pane (scrollable) ──
+                # ── RIGHT half: Info Pane with clickable tabs (scrollable) ──
                 Frame(
-                    title="[F1] Pending  [F2] Executed  [F3] Option Chain  [F4] Advisor  [Ctrl+←→: resize]",
+                    title="",
                     body=HSplit([
+                        self.tab_bar_window,
+                        Window(height=1, char="─", style="class:divider"),
                         Window(
                             content=self.market_indices_control,
                             height=1,

{kitecli-0.2.1 → kitecli-0.2.3}/kitecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.2.1
+Version: 0.2.3
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT

{kitecli-0.2.1 → kitecli-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kitecli"
-version = "0.2.1"
+version = "0.2.3"
 description = "KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)"
 readme = "README.md"
 requires-python = ">=3.10"

{kitecli-0.2.1 → kitecli-0.2.3}/tests/test_ui.py

@@ -94,5 +94,27 @@ class TestUIComponents(unittest.IsolatedAsyncioTestCase):
         mock_run_coroutine.assert_called_once()
         self.session.log_message.assert_any_call("Triggering manual WebSocket and REST reconnection...")
 
+    @patch("cli.live_session.KCLILiveSession._update_info_buffer")
+    def test_info_pane_tabs(self, mock_update_buffer):
+        self.session.info_mode = "orders_pending"
+        fragments = self.session._get_tab_bar_text()
+        
+        self.assertEqual(fragments[1][0], "class:tab.active")
+        self.assertEqual(fragments[1][1], " Pending ")
+        self.assertEqual(fragments[3][0], "class:tab.inactive")
+        self.assertEqual(fragments[3][1], " Executed ")
+        
+        click_handler_oc = fragments[5][2]
+        
+        from prompt_toolkit.mouse_events import MouseEventType
+        mock_event = MagicMock()
+        mock_event.event_type = MouseEventType.MOUSE_UP
+        
+        click_handler_oc(mock_event)
+        
+        self.assertEqual(self.session.info_mode, "oc")
+        mock_update_buffer.assert_called_once()
+        self.session.app.invalidate.assert_called_once()
+
 if __name__ == "__main__":
     unittest.main()