quantglide-ibkr 1.0.0__tar.gz

quantglide_ibkr-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+.env
+*.log

quantglide_ibkr-1.0.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: quantglide-ibkr
+Version: 1.0.0
+Summary: QuantGlide IBKR relay — polls for trade signals and places orders via IB Gateway
+License: Proprietary
+Requires-Python: >=3.9
+Requires-Dist: ib-insync>=0.9.86
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: supabase>=2.0.0
+Description-Content-Type: text/markdown
+
+# quantglide-ibkr
+
+QuantGlide IBKR relay agent. Polls for trade signals from QuantGlide and places orders via IB Gateway.
+
+## Requirements
+
+- Python 3.9+
+- IB Gateway running locally ([download](https://www.interactivebrokers.com/en/trading/ibgateway-stable.php))
+
+## Install
+
+```bash
+pip install quantglide-ibkr
+```
+
+## Setup (one time)
+
+1. Go to the QuantGlide dashboard → Settings → IBKR
+2. Copy your setup token
+3. Run:
+
+```bash
+quantglide-ibkr --token <paste_token_here>
+```
+
+## Run
+
+```bash
+quantglide-ibkr
+```
+
+For paper trading (IB Gateway on port 4002):
+
+```bash
+quantglide-ibkr --port 4002
+```
+
+Test without placing real orders:
+
+```bash
+quantglide-ibkr --dry-run
+```
+
+## How it works
+
+The agent connects to IB Gateway on your machine and polls QuantGlide for trade signals. When a signal arrives, it places the order via IB Gateway. Keep the agent running during trading hours (10:25–13:00 ET).
+
+Config is stored in `~/.quantglide/.env`. Refresh tokens are automatically rotated.

quantglide_ibkr-1.0.0/README.md

@@ -0,0 +1,48 @@
+# quantglide-ibkr
+
+QuantGlide IBKR relay agent. Polls for trade signals from QuantGlide and places orders via IB Gateway.
+
+## Requirements
+
+- Python 3.9+
+- IB Gateway running locally ([download](https://www.interactivebrokers.com/en/trading/ibgateway-stable.php))
+
+## Install
+
+```bash
+pip install quantglide-ibkr
+```
+
+## Setup (one time)
+
+1. Go to the QuantGlide dashboard → Settings → IBKR
+2. Copy your setup token
+3. Run:
+
+```bash
+quantglide-ibkr --token <paste_token_here>
+```
+
+## Run
+
+```bash
+quantglide-ibkr
+```
+
+For paper trading (IB Gateway on port 4002):
+
+```bash
+quantglide-ibkr --port 4002
+```
+
+Test without placing real orders:
+
+```bash
+quantglide-ibkr --dry-run
+```
+
+## How it works
+
+The agent connects to IB Gateway on your machine and polls QuantGlide for trade signals. When a signal arrives, it places the order via IB Gateway. Keep the agent running during trading hours (10:25–13:00 ET).
+
+Config is stored in `~/.quantglide/.env`. Refresh tokens are automatically rotated.

quantglide_ibkr-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "quantglide-ibkr"
+version = "1.0.0"
+description = "QuantGlide IBKR relay — polls for trade signals and places orders via IB Gateway"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+dependencies = [
+    "supabase>=2.0.0",
+    "python-dotenv>=1.0.0",
+    "ib_insync>=0.9.86",
+]
+
+[project.scripts]
+quantglide-ibkr = "quantglide_ibkr.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/quantglide_ibkr"]

quantglide_ibkr-1.0.0/src/quantglide_ibkr/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

quantglide_ibkr-1.0.0/src/quantglide_ibkr/adapter.py

@@ -0,0 +1,370 @@
+# ibkr_adapter_gw.py
+"""
+IBKR order adapter using the IB Gateway socket API (ib_insync).
+
+Requires IB Gateway or TWS running:
+  - Port 4001: IB Gateway live
+  - Port 4002: IB Gateway paper
+  - Port 7496: TWS live
+  - Port 7497: TWS paper
+"""
+import logging
+import math
+import time
+from ib_insync import IB, Option, Contract, ComboLeg, LimitOrder, MarketOrder
+
+logger = logging.getLogger('quantglide_ibkr.adapter')
+
+TICK_SIZE = 0.05
+MIN_CREDIT_DEFAULT = 0.10  # IBKR rejects < $0.10 as "guaranteed-to-lose"
+POLL_INTERVAL_S = 3
+MAX_REPRICE_STEPS = 6
+STEP_WAIT_S = 8  # seconds to wait at each price level before repricing
+
+RECONNECT_BACKOFF_S = [1, 2, 5, 10, 30, 60]
+MAX_RECONNECT_ATTEMPTS = 10
+
+
+class IBKRGatewayAdapter:
+    """IBKR order adapter using IB Gateway socket API (ib_insync)."""
+
+    def __init__(self, host='127.0.0.1', port=4001, client_id=1, account=None):
+        self.ib = IB()
+        self.host = host
+        self.port = port
+        self.client_id = client_id
+        self._connected = False
+        self._intentional_disconnect = False
+        self.acct_id = None
+        self._account_override = account  # explicit sub-account for FA accounts
+        self.ib.disconnectedEvent += self._on_disconnect
+
+    @property
+    def connected(self) -> bool:
+        """True only if the underlying socket is actually connected."""
+        return self._connected and self.ib.isConnected()
+
+    # ── Connection ──────────────────────────────────────────────────────
+
+    def _on_disconnect(self):
+        """Callback fired by ib_insync when the socket drops."""
+        self._connected = False
+        if not self._intentional_disconnect:
+            logger.warning("[IBKR] Disconnected from gateway (disconnectedEvent fired)")
+
+    def connect(self):
+        """Connect to IB Gateway via socket."""
+        if self.ib.isConnected():
+            self.ib.disconnect()
+        self.ib.connect(
+            host=self.host,
+            port=self.port,
+            clientId=self.client_id,
+            timeout=20,
+        )
+        accounts = self.ib.managedAccounts()
+        if not accounts:
+            raise RuntimeError("No IBKR accounts found")
+        if self._account_override:
+            if self._account_override not in accounts:
+                raise RuntimeError(
+                    f"Specified ibkr_account '{self._account_override}' not in "
+                    f"managed accounts: {accounts}"
+                )
+            self.acct_id = self._account_override
+        else:
+            self.acct_id = accounts[0]
+        self._connected = True
+        logger.info(
+            f"[IBKR] Connected via Gateway socket "
+            f"{self.host}:{self.port}, account={self.acct_id} "
+            f"(managed: {accounts})"
+        )
+
+    def ensure_connected(self) -> bool:
+        """Check connection and reconnect if needed. Returns True if connected."""
+        if self.connected:
+            return True
+        logger.warning("[IBKR] Connection lost, attempting to reconnect...")
+        for attempt in range(1, MAX_RECONNECT_ATTEMPTS + 1):
+            backoff = RECONNECT_BACKOFF_S[min(attempt - 1, len(RECONNECT_BACKOFF_S) - 1)]
+            try:
+                self.connect()
+                logger.info(f"[IBKR] Reconnected on attempt {attempt}")
+                return True
+            except Exception as e:
+                logger.warning(
+                    f"[IBKR] Reconnect attempt {attempt}/{MAX_RECONNECT_ATTEMPTS} "
+                    f"failed: {e}  (retry in {backoff}s)"
+                )
+                time.sleep(backoff)
+        logger.error(
+            f"[IBKR] Failed to reconnect after {MAX_RECONNECT_ATTEMPTS} attempts"
+        )
+        return False
+
+    def disconnect(self):
+        if self._connected or self.ib.isConnected():
+            self._intentional_disconnect = True
+            self.ib.disconnect()
+            self._connected = False
+            self._intentional_disconnect = False
+            logger.info("[IBKR] Disconnected")
+
+    # ── Market data helpers ────────────────────────────────────────────
+
+    def _get_option_mid(self, contract) -> float | None:
+        """Request snapshot market data and return mid price.
+        Uses regulatory snapshot ($0.03/req for options) — no subscription needed."""
+        self.ib.reqMarketDataType(1)  # 1 = live
+        self.ib.reqMktData(contract, snapshot=False, regulatorySnapshot=True)
+        self.ib.sleep(3)
+        ticker = self.ib.ticker(contract)
+        if ticker is None:
+            return None
+
+        bid = ticker.bid
+        ask = ticker.ask
+
+        # bid/ask can be nan or -1 when unavailable
+        bid_ok = bid is not None and math.isfinite(bid) and bid > 0
+        ask_ok = ask is not None and math.isfinite(ask) and ask > 0
+
+        if bid_ok and ask_ok:
+            return (bid + ask) / 2.0
+        if bid_ok:
+            return bid
+        if ask_ok:
+            return ask
+        return None
+
+    def _get_spread_mid_credit(self, short_contract, long_contract) -> float | None:
+        """Compute mid-price credit for a vertical spread from IBKR market data."""
+        short_mid = self._get_option_mid(short_contract)
+        long_mid = self._get_option_mid(long_contract)
+
+        logger.info(
+            f"[IBKR] Leg prices: short_mid={short_mid} long_mid={long_mid}"
+        )
+
+        if short_mid is None or long_mid is None:
+            return None
+
+        credit = short_mid - long_mid
+        return credit if credit > 0 else None
+
+    @staticmethod
+    def _round_down_tick(price: float) -> float:
+        """Round price DOWN to nearest tick (float-safe)."""
+        return round(math.floor(round(price, 4) / TICK_SIZE) * TICK_SIZE, 2)
+
+    @staticmethod
+    def _round_tick(price: float) -> float:
+        """Round price to nearest tick."""
+        return round(round(price / TICK_SIZE) * TICK_SIZE, 2)
+
+    def _cancel_and_wait(self, trade, timeout_s=5) -> bool:
+        """Cancel an order and wait for acknowledgement. Returns True if confirmed cancelled."""
+        try:
+            self.ib.cancelOrder(trade.order)
+        except Exception as e:
+            logger.warning(f"[IBKR] Cancel request failed: {e}")
+            return False
+        elapsed = 0
+        while elapsed < timeout_s:
+            self.ib.sleep(1)
+            elapsed += 1
+            status = trade.orderStatus.status
+            if status in ('Cancelled', 'ApiCancelled'):
+                return True
+            if status == 'Filled':
+                return False  # filled during cancel
+        logger.warning(
+            f"[IBKR] Cancel not confirmed after {timeout_s}s, "
+            f"status={trade.orderStatus.status}"
+        )
+        return False
+
+    # ── Place orders ────────────────────────────────────────────────────
+
+    def place_credit_spread(
+        self,
+        symbol,
+        expiration,      # "YYYYMMDD"
+        short_strike,    # float
+        long_strike,     # float
+        is_put,          # bool
+        qty,             # int
+        limit_price=None,  # optional override; if None, adapter fetches mid
+        min_credit=MIN_CREDIT_DEFAULT,
+    ):
+        """
+        Place a vertical credit spread with linear reprice.
+
+        1. Qualify contracts & fetch IBKR market data for mid credit.
+        2. Place limit order at mid (rounded to tick).
+        3. Poll for fill; step price down by one tick each step.
+        4. If price hits min_credit, final poll then cancel if unfilled.
+
+        Returns ib_insync Trade object if filled, None otherwise.
+        """
+        if not self.ensure_connected():
+            logger.error("[IBKR] Not connected and reconnect failed")
+            return None
+
+        right = "P" if is_put else "C"
+
+        short_contract = Option(symbol, expiration, short_strike, right, 'CBOE')
+        long_contract = Option(symbol, expiration, long_strike, right, 'CBOE')
+
+        try:
+            self.ib.qualifyContracts(short_contract, long_contract)
+        except Exception as e:
+            logger.error(f"[IBKR] Contract qualification failed: {e}")
+            return None
+
+        if not short_contract.conId or not long_contract.conId:
+            logger.error(
+                f"[IBKR] Missing conIds after qualify: "
+                f"short={short_contract.conId} long={long_contract.conId}"
+            )
+            return None
+
+        # ── Get mid credit from IBKR market data ──
+        mid_credit = self._get_spread_mid_credit(short_contract, long_contract)
+
+        if mid_credit is not None and mid_credit > 0:
+            start_price = self._round_down_tick(mid_credit)
+        elif limit_price is not None and limit_price > 0:
+            logger.warning(
+                f"[IBKR] Could not get mid from IBKR, using caller price: {limit_price:.2f}"
+            )
+            start_price = self._round_tick(limit_price)
+        else:
+            logger.error("[IBKR] No valid price available for spread")
+            return None
+
+        start_price = max(start_price, min_credit)
+
+        logger.info(
+            f"[IBKR] Spread pricing: mid_credit={mid_credit} "
+            f"start_price={start_price:.2f} min_credit={min_credit:.2f}"
+        )
+
+        # ── Build combo (BAG) contract ──
+        combo = Contract()
+        combo.symbol = symbol
+        combo.secType = 'BAG'
+        combo.currency = 'USD'
+        combo.exchange = 'SMART'
+
+        leg1 = ComboLeg()
+        leg1.conId = short_contract.conId
+        leg1.ratio = 1
+        leg1.action = 'SELL'
+        leg1.exchange = 'CBOE'
+
+        leg2 = ComboLeg()
+        leg2.conId = long_contract.conId
+        leg2.ratio = 1
+        leg2.action = 'BUY'
+        leg2.exchange = 'CBOE'
+
+        combo.comboLegs = [leg1, leg2]
+
+        # ── Linear reprice loop ──
+        price = start_price
+        last_trade = None
+
+        for step in range(MAX_REPRICE_STEPS):
+            price = round(price, 2)
+
+            order = LimitOrder(
+                action='BUY',
+                totalQuantity=qty,
+                lmtPrice=-price,
+                tif='DAY',
+                account=self.acct_id,
+            )
+
+            logger.info(
+                f"[IBKR] Step {step}: placing credit spread {symbol} "
+                f"{short_strike}/{long_strike} {right} qty={qty} "
+                f"@ ${price:.2f} credit | "
+                f"short_conId={short_contract.conId} long_conId={long_contract.conId}"
+            )
+
+            try:
+                trade = self.ib.placeOrder(combo, order)
+                last_trade = trade
+                logger.info(
+                    f"[IBKR] Order submitted: orderId={trade.order.orderId} "
+                    f"status={trade.orderStatus.status}"
+                )
+            except Exception as e:
+                logger.error(f"[IBKR] Failed to place spread: {e}")
+                return None
+
+            # Poll for fill
+            elapsed = 0
+            while elapsed < STEP_WAIT_S:
+                self.ib.sleep(POLL_INTERVAL_S)
+                elapsed += POLL_INTERVAL_S
+                status = trade.orderStatus.status
+                logger.info(
+                    f"[IBKR] Poll orderId={trade.order.orderId} "
+                    f"status={status} filled={trade.orderStatus.filled}"
+                )
+                if status == 'Filled':
+                    logger.info(
+                        f"[IBKR] FILLED @ ${price:.2f} credit "
+                        f"(step={step}, orderId={trade.order.orderId})"
+                    )
+                    return trade
+                if status in ('Cancelled', 'ApiCancelled', 'Inactive'):
+                    logger.warning(f"[IBKR] Order rejected: {status}")
+                    return None
+
+            # Not filled — check if we can reprice lower
+            next_price = round(price - TICK_SIZE, 2)
+            if next_price < min_credit:
+                logger.info(f"[IBKR] At credit floor ${price:.2f}, final poll...")
+                extra = 0
+                while extra < STEP_WAIT_S:
+                    self.ib.sleep(POLL_INTERVAL_S)
+                    extra += POLL_INTERVAL_S
+                    if trade.orderStatus.status == 'Filled':
+                        logger.info(f"[IBKR] FILLED at floor @ ${price:.2f}")
+                        return trade
+                self._cancel_and_wait(trade)
+                if trade.orderStatus.status == 'Filled':
+                    logger.info(f"[IBKR] Filled during cancel @ ${price:.2f}")
+                    return trade
+                logger.info("[IBKR] Cancelled unfilled order at credit floor")
+                return None
+
+            self._cancel_and_wait(trade)
+            if trade.orderStatus.status == 'Filled':
+                logger.info(f"[IBKR] Filled during cancel @ ${price:.2f}")
+                return trade
+            if trade.orderStatus.status not in ('Cancelled', 'ApiCancelled'):
+                logger.warning(
+                    f"[IBKR] Cancel not confirmed (status={trade.orderStatus.status}), "
+                    f"aborting reprice to avoid duplicate orders"
+                )
+                return None
+
+            logger.info(
+                f"[IBKR] Cancelled orderId={trade.order.orderId} "
+                f"for reprice {price:.2f} -> {next_price:.2f}"
+            )
+            price = next_price
+
+        if last_trade and last_trade.orderStatus.status not in (
+            'Filled', 'Cancelled', 'ApiCancelled', 'Inactive'
+        ):
+            self._cancel_and_wait(last_trade)
+            if last_trade.orderStatus.status == 'Filled':
+                return last_trade
+        logger.info(f"[IBKR] Exhausted {MAX_REPRICE_STEPS} reprice steps, no fill")
+        return None

quantglide_ibkr-1.0.0/src/quantglide_ibkr/agent.py

@@ -0,0 +1,322 @@
+"""
+IBKR Signal Agent — polls Supabase for trade signals and places orders via IB Gateway.
+"""
+import logging
+import os
+import time
+import urllib.request
+import urllib.error
+import json
+from datetime import datetime, timezone
+from logging.handlers import RotatingFileHandler
+
+from dotenv import dotenv_values
+from supabase import create_client
+from zoneinfo import ZoneInfo
+
+from quantglide_ibkr.adapter import IBKRGatewayAdapter
+
+EASTERN = ZoneInfo("America/New_York")
+
+POLL_INTERVAL_S = 2
+MIN_CREDIT = 0.10
+
+EXCHANGE_URL = "https://app.quantglide.com/api/ibkr/exchange"
+
+
+# ── Config ───────────────────────────────────────────────────────────────────
+
+def load_config(env_path: str) -> dict:
+    vals = dotenv_values(env_path)
+    def get(key, default=""):
+        return (vals.get(key) or os.environ.get(key) or default).strip()
+    return {
+        "QUANTGLIDE_TOKEN": get("QUANTGLIDE_TOKEN"),
+        "IBKR_HOST":        get("IBKR_HOST", "127.0.0.1"),
+        "IBKR_PORT":        int(get("IBKR_PORT", "4001")),
+        "IBKR_CLIENT_ID":   int(get("IBKR_CLIENT_ID", "10")),
+    }
+
+
+# ── Logger ───────────────────────────────────────────────────────────────────
+
+def setup_logger() -> logging.Logger:
+    lgr = logging.getLogger("quantglide_ibkr")
+    if lgr.handlers:
+        return lgr  # already configured
+    lgr.setLevel(logging.INFO)
+    fmt = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    fh = RotatingFileHandler("ibkr_agent.log", maxBytes=5 * 1024 * 1024, backupCount=2)
+    fh.setFormatter(fmt)
+    ch = logging.StreamHandler()
+    ch.setFormatter(fmt)
+    lgr.addHandler(fh)
+    lgr.addHandler(ch)
+    return lgr
+
+
+# ── Credential exchange ───────────────────────────────────────────────────────
+
+def exchange_token(token: str, logger: logging.Logger) -> dict:
+    """
+    Exchange the permanent UUID token for fresh credentials from QuantGlide.
+    Called on every startup — no local credential storage needed.
+    """
+    logger.info("[AUTH] Fetching credentials from QuantGlide...")
+    body = json.dumps({"token": token}).encode()
+    req = urllib.request.Request(
+        EXCHANGE_URL,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            payload = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode()
+        if e.code == 401 or e.code == 404:
+            raise RuntimeError(
+                "Setup token not recognised.\n"
+                "Re-copy your token from the QuantGlide dashboard and re-run:\n"
+                "    quantglide-ibkr --token <token>"
+            )
+        raise RuntimeError(f"Credential exchange failed ({e.code}): {body}")
+    except urllib.error.URLError as e:
+        raise RuntimeError(
+            f"Could not reach QuantGlide ({e.reason}).\n"
+            "Check your internet connection and try again."
+        )
+
+    required = {"supabase_url", "supabase_key", "refresh_token", "user_id"}
+    missing = required - payload.keys()
+    if missing:
+        raise RuntimeError(f"Incomplete response from exchange endpoint: missing {missing}")
+
+    logger.info(f"[AUTH] Credentials received  user={payload['user_id']}")
+    return payload
+
+
+# ── Supabase auth ─────────────────────────────────────────────────────────────
+
+def get_supabase(creds: dict, logger: logging.Logger):
+    sb = create_client(creds["supabase_url"], creds["supabase_key"])
+    result = sb.auth.refresh_session(creds["refresh_token"])
+    if not result.session:
+        raise RuntimeError(
+            "Supabase session could not be established.\n"
+            "This is unusual — try re-running the agent. If it persists, "
+            "re-copy your token from the QuantGlide dashboard."
+        )
+    logger.info("[AUTH] Authenticated with QuantGlide")
+    return sb
+
+
+# ── Active check ──────────────────────────────────────────────────────────────
+
+def is_agent_active(sb, user_id: str, logger: logging.Logger) -> bool:
+    try:
+        resp = (
+            sb.table("trading_config")
+            .select("active")
+            .eq("user_id", user_id)
+            .execute()
+        )
+        if resp.data and not resp.data[0].get("active", True):
+            return False
+    except Exception as e:
+        logger.warning(f"[ACTIVE] Check failed, proceeding: {e}")
+    return True
+
+
+# ── Order execution ───────────────────────────────────────────────────────────
+
+def execute_signal(signal: dict, ibkr: IBKRGatewayAdapter, logger: logging.Logger) -> tuple[str, float | None]:
+    direction    = signal["direction"]
+    is_put       = direction == "bull_put"
+    short_strike = float(signal["short_strike"])
+    long_strike  = float(signal["long_strike"])
+    qty          = int(signal["qty"])
+    expiry_ibkr  = signal["expiration_date"].replace("-", "")
+    limit_credit = signal.get("limit_credit")
+
+    logger.info(
+        f"[EXEC] {direction} {short_strike}/{long_strike} qty={qty} expiry={expiry_ibkr}"
+        + (f" hint_credit={limit_credit:.2f}" if limit_credit else "")
+    )
+
+    try:
+        trade = ibkr.place_credit_spread(
+            symbol="SPX",
+            expiration=expiry_ibkr,
+            short_strike=short_strike,
+            long_strike=long_strike,
+            is_put=is_put,
+            qty=qty,
+            limit_price=limit_credit,
+            min_credit=MIN_CREDIT,
+        )
+    except Exception as e:
+        logger.error(f"[EXEC] Error: {e}")
+        return "error", None
+
+    if trade and trade.orderStatus.status == "Filled":
+        fill_price = abs(trade.orderStatus.avgFillPrice)
+        logger.info(f"[EXEC] FILLED @ {fill_price:.2f}")
+        return "filled", fill_price
+
+    logger.info("[EXEC] Not filled")
+    return "not_filled", None
+
+
+def update_signal(sb, signal_id: str, status: str, fill_price=None, error=None, logger=None):
+    update = {
+        "status": status,
+        "agent_result": status,
+        "agent_completed_at": datetime.now(timezone.utc).isoformat(),
+    }
+    if fill_price is not None:
+        update["agent_fill_price"] = fill_price
+    if error:
+        update["agent_error"] = error
+    try:
+        sb.table("trade_signals").update(update).eq("id", signal_id).execute()
+    except Exception as e:
+        if logger:
+            logger.error(f"[RELAY] Failed to update signal {signal_id}: {e}")
+
+
+# ── Main loop ─────────────────────────────────────────────────────────────────
+
+def run(env_path: str, no_time_gate: bool = False, dry_run: bool = False):
+    cfg = load_config(env_path)
+    logger = setup_logger()
+
+    if not cfg["QUANTGLIDE_TOKEN"]:
+        print("No setup token found. Run:")
+        print("    quantglide-ibkr --token <paste_token_from_dashboard>")
+        raise SystemExit(1)
+
+    # Exchange UUID for fresh credentials on every startup — nothing to rotate locally
+    creds = exchange_token(cfg["QUANTGLIDE_TOKEN"], logger)
+    user_id = creds["user_id"]
+
+    port = cfg["IBKR_PORT"]
+    mode = "paper" if port == 4002 else "live"
+    logger.info(f"[BOOT] QuantGlide IBKR Agent  user={user_id}  gateway={cfg['IBKR_HOST']}:{port} ({mode})")
+    if no_time_gate:
+        logger.info("[BOOT] Time gate disabled")
+    if dry_run:
+        logger.info("[BOOT] Dry run — signals will be claimed but no orders placed")
+
+    sb = get_supabase(creds, logger)
+
+    logger.info("[DB] Checking Supabase connection...")
+    try:
+        sb.table("trade_signals").select("id").eq("target_user_id", user_id).limit(1).execute()
+        logger.info("[DB] Connected OK")
+    except Exception as e:
+        logger.warning(f"[DB] Could not read trade_signals: {e}")
+
+    ibkr = IBKRGatewayAdapter(
+        host=cfg["IBKR_HOST"],
+        port=port,
+        client_id=cfg["IBKR_CLIENT_ID"],
+        account=None,
+    )
+
+    logger.info(f"[GW] Connecting to IB Gateway at {cfg['IBKR_HOST']}:{port}...")
+    try:
+        ibkr.connect()
+        logger.info(f"[GW] Connected  account={ibkr.acct_id}")
+        ibkr.disconnect()
+    except Exception as e:
+        logger.warning(
+            f"[GW] Could not reach IB Gateway — {e}\n"
+            f"      Make sure IB Gateway is running with API connections enabled.\n"
+            f"      The agent will retry when a signal arrives."
+        )
+
+    processed_today: set[str] = set()
+    last_date = None
+
+    while True:
+        now = datetime.now(EASTERN)
+        today = now.date()
+
+        if last_date != today:
+            processed_today.clear()
+            last_date = today
+            logger.info(f"[DAY] {today}")
+
+        if not no_time_gate:
+            h, m = now.hour, now.minute
+            if today.weekday() >= 5 or h < 10 or (h == 10 and m < 25) or h >= 13:
+                time.sleep(30 if h < 13 else 3600)
+                continue
+
+        try:
+            resp = (
+                sb.table("trade_signals")
+                .select("*")
+                .eq("status", "pending")
+                .eq("signal_date", str(today))
+                .eq("target_user_id", user_id)
+                .execute()
+            )
+        except Exception as e:
+            logger.error(f"[POLL] Query failed: {e}")
+            time.sleep(10)
+            continue
+
+        for signal in (resp.data or []):
+            sig_id = signal["id"]
+            if sig_id in processed_today:
+                continue
+
+            logger.info(f"[SIGNAL] {signal['direction']} {signal['short_strike']}/{signal['long_strike']} qty={signal['qty']}")
+
+            try:
+                claim = sb.table("trade_signals").update({
+                    "status": "claimed",
+                    "agent_claimed_at": datetime.now(timezone.utc).isoformat(),
+                }).eq("id", sig_id).eq("status", "pending").execute()
+                if not claim.data:
+                    processed_today.add(sig_id)
+                    continue
+            except Exception as e:
+                logger.error(f"[SIGNAL] Claim failed: {e}")
+                continue
+
+            processed_today.add(sig_id)
+
+            try:
+                check = sb.table("trade_signals").select("status").eq("id", sig_id).execute()
+                if check.data and check.data[0]["status"] == "cancelled":
+                    logger.info(f"[SIGNAL] {sig_id} cancelled before execution")
+                    continue
+            except Exception:
+                pass
+
+            if not is_agent_active(sb, user_id, logger):
+                logger.info("[SKIP] Bot is deactivated in dashboard")
+                update_signal(sb, sig_id, "skip", logger=logger)
+                continue
+
+            if dry_run:
+                logger.info(f"[DRY RUN] Would place {signal['direction']} {signal['short_strike']}/{signal['long_strike']} qty={signal['qty']}")
+                update_signal(sb, sig_id, "filled", fill_price=signal.get("limit_credit"), logger=logger)
+                continue
+
+            if not ibkr.connected:
+                try:
+                    ibkr.connect()
+                except Exception as e:
+                    logger.error(f"[IBKR] Connection failed: {e}")
+                    update_signal(sb, sig_id, "error", error=str(e), logger=logger)
+                    continue
+
+            result, fill_price = execute_signal(signal, ibkr, logger)
+            update_signal(sb, sig_id, result, fill_price=fill_price, logger=logger)
+
+        time.sleep(POLL_INTERVAL_S)

quantglide_ibkr-1.0.0/src/quantglide_ibkr/cli.py

@@ -0,0 +1,108 @@
+"""
+quantglide-ibkr CLI entry point.
+
+First-time setup:
+    quantglide-ibkr --token <token_from_dashboard>
+
+Subsequent runs:
+    quantglide-ibkr
+    quantglide-ibkr --port 4002   # switch to paper trading
+    quantglide-ibkr --dry-run     # test without placing orders
+"""
+import argparse
+import sys
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".quantglide"
+CONFIG_FILE = CONFIG_DIR / ".env"
+
+
+def _read_config() -> dict:
+    from dotenv import dotenv_values
+    return dotenv_values(str(CONFIG_FILE))
+
+
+def _write_config(data: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    lines = []
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE) as f:
+            lines = f.readlines()
+    for key, value in data.items():
+        found = False
+        for i, line in enumerate(lines):
+            if line.startswith(f"{key}="):
+                lines[i] = f"{key}={value}\n"
+                found = True
+                break
+        if not found:
+            lines.append(f"{key}={value}\n")
+    with open(CONFIG_FILE, "w") as f:
+        f.writelines(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="quantglide-ibkr",
+        description="QuantGlide IBKR relay agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  First-time setup:
+    quantglide-ibkr --token <paste_token_from_dashboard>
+
+  Start the agent:
+    quantglide-ibkr
+
+  Paper trading:
+    quantglide-ibkr --port 4002
+
+  Test without placing real orders:
+    quantglide-ibkr --dry-run
+        """,
+    )
+    parser.add_argument("--token", metavar="TOKEN",
+                        help="Setup token from the QuantGlide dashboard (first-time only)")
+    parser.add_argument("--port", type=int, choices=[4001, 4002],
+                        help="IB Gateway port: 4001=live (default), 4002=paper")
+    parser.add_argument("--no-time-gate", action="store_true",
+                        help="Skip trading hours check (useful for testing)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Claim signals but don't place real orders")
+    args = parser.parse_args()
+
+    # ── First-time setup: just save the token UUID ────────────────────────────
+    if args.token:
+        _write_config({
+            "QUANTGLIDE_TOKEN": args.token.strip(),
+            "IBKR_HOST":        "127.0.0.1",
+            "IBKR_PORT":        str(args.port or 4001),
+            "IBKR_CLIENT_ID":   "10",
+        })
+        print(f"Setup complete. Config saved to {CONFIG_FILE}")
+        print()
+        print("Make sure IB Gateway is running, then start the agent:")
+        print("    quantglide-ibkr")
+        return
+
+    # ── Config must exist ─────────────────────────────────────────────────────
+    if not CONFIG_FILE.exists():
+        print("No config found. Run setup first:")
+        print()
+        print("    quantglide-ibkr --token <paste_token_from_dashboard>")
+        print()
+        print("Get your token from the QuantGlide dashboard under Settings → IBKR.")
+        sys.exit(1)
+
+    # ── Apply port override ───────────────────────────────────────────────────
+    if args.port:
+        _write_config({"IBKR_PORT": str(args.port)})
+        print(f"Port set to {args.port} ({'paper' if args.port == 4002 else 'live'} trading)")
+
+    # ── Launch agent ──────────────────────────────────────────────────────────
+    from quantglide_ibkr.agent import run
+    run(
+        env_path=str(CONFIG_FILE),
+        no_time_gate=args.no_time_gate,
+        dry_run=args.dry_run,
+    )