Update app.py

app.py

@@ -861,13 +861,89 @@ async def webhook(request: Request):
             res = place_market_order(ssl_sock, account_id, symbol_id, ProtoOATradeSide.SELL, current_trade_volume)
             execution_msg = f"Opened SELL position for {ticker}. Order Result: {res.get('status')} {res.get('message', '')}"
             
-        elif action in ["STOP-TRADE", "CLOSE"]:
-            # Close all active positions on this symbol
+        elif action == "CLOSE":
+            # CLOSE = force-close ALL positions on this symbol (manual override)
             if len(symbol_positions) > 0:
                 for p in symbol_positions:
                     side = ProtoOATradeSide.SELL if p.tradeData.tradeSide == 1 else ProtoOATradeSide.BUY
                     place_market_order(ssl_sock, account_id, symbol_id, side, p.tradeData.volume, position_id=p.positionId)
-                execution_msg = f"Closed {len(symbol_positions)} open positions on {ticker}."
+                execution_msg = f"CLOSE: Force-closed {len(symbol_positions)} positions on {ticker}."
+            else:
+                execution_msg = f"No open positions on {ticker} to close."
+                
+        elif action == "STOP-TRADE":
+            # STOP-TRADE = only close PROFITABLE positions, leave losing ones open
+            if len(symbol_positions) > 0:
+                # Get current spot price (bid/ask) for this symbol
+                current_bid = None
+                current_ask = None
+                try:
+                    spot_req = ProtoOASubscribeSpotsReq()
+                    spot_req.ctidTraderAccountId = int(account_id)
+                    spot_req.symbolId.append(int(symbol_id))
+                    send_proto_message(ssl_sock, spot_req, 2127)
+                    
+                    # Read responses until we get a spot event
+                    for _ in range(10):
+                        proto_msg = receive_proto_message(ssl_sock)
+                        if not proto_msg:
+                            break
+                        if proto_msg.payloadType == 2131:  # ProtoOASpotEvent
+                            spot = ProtoOASpotEvent()
+                            spot.ParseFromString(proto_msg.payload)
+                            if hasattr(spot, 'bid') and spot.bid:
+                                current_bid = spot.bid / 100000.0  # Convert from protocol price
+                            if hasattr(spot, 'ask') and spot.ask:
+                                current_ask = spot.ask / 100000.0
+                            if current_bid and current_ask:
+                                break
+                        elif proto_msg.payloadType == 2128:  # Subscribe confirmation
+                            continue
+                    
+                    # Unsubscribe from spots
+                    try:
+                        unsub_req = ProtoOAUnsubscribeSpotsReq()
+                        unsub_req.ctidTraderAccountId = int(account_id)
+                        unsub_req.symbolId.append(int(symbol_id))
+                        send_proto_message(ssl_sock, unsub_req, 2129)
+                        receive_proto_message(ssl_sock)  # Consume the response
+                    except Exception:
+                        pass
+                except Exception as e:
+                    logger.warning(f"Could not fetch spot price: {e}")
+                
+                closed_count = 0
+                skipped_count = 0
+                
+                for p in symbol_positions:
+                    entry_price = p.price  # Entry price of the position
+                    is_buy = p.tradeData.tradeSide == 1
+                    
+                    # Determine if position is profitable
+                    in_profit = False
+                    if current_bid and current_ask:
+                        if is_buy:
+                            # BUY position profits when current bid > entry price
+                            in_profit = current_bid > entry_price
+                        else:
+                            # SELL position profits when entry price > current ask
+                            in_profit = entry_price > current_ask
+                    else:
+                        # Fallback: use the swap field as a rough P&L indicator
+                        # If we couldn't get spot prices, check if swap is positive
+                        in_profit = getattr(p, 'swap', 0) > 0
+                        logger.warning(f"No spot price available, using swap as fallback for position {p.positionId}")
+                    
+                    if in_profit:
+                        side = ProtoOATradeSide.SELL if is_buy else ProtoOATradeSide.BUY
+                        logger.info(f"Closing PROFITABLE {'BUY' if is_buy else 'SELL'} position {p.positionId} (entry: {entry_price})")
+                        place_market_order(ssl_sock, account_id, symbol_id, side, p.tradeData.volume, position_id=p.positionId)
+                        closed_count += 1
+                    else:
+                        logger.info(f"KEEPING losing {'BUY' if is_buy else 'SELL'} position {p.positionId} (entry: {entry_price})")
+                        skipped_count += 1
+                
+                execution_msg = f"STOP-TRADE: Closed {closed_count} profitable position(s), kept {skipped_count} losing position(s) on {ticker}."
             else:
                 execution_msg = f"No open positions on {ticker} to close."