hedgequantx 1.2.41 → 1.2.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.2.41",
+  "version": "1.2.43",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {

package/src/app.js

@@ -359,19 +359,24 @@ const rithmicMenu = async () => {
 
     if (result.success) {
       spinner.text = 'Fetching accounts...';
-      await service.getTradingAccounts();
+      const accResult = await service.getTradingAccounts();
       
       connections.add('rithmic', service, service.propfirm.name);
       currentService = service;
       currentPlatform = 'rithmic';
-      spinner.succeed(`Connected to ${service.propfirm.name}`);
+      spinner.succeed(`Connected to ${service.propfirm.name} (${accResult.accounts?.length || 0} accounts)`);
+      
+      // Small pause to see the success message
+      await new Promise(r => setTimeout(r, 1500));
       return service;
     } else {
       spinner.fail(result.error || 'Authentication failed');
+      await new Promise(r => setTimeout(r, 2000));
       return null;
     }
   } catch (error) {
-    spinner.fail(error.message);
+    spinner.fail(`Connection error: ${error.message}`);
+    await new Promise(r => setTimeout(r, 2000));
     return null;
   }
 };
@@ -583,10 +588,14 @@ const dashboardMenu = async (service) => {
   console.log(chalk.cyan('║') + chalk.white.bold(centerText('DASHBOARD', innerWidth)) + chalk.cyan('║'));
   console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
   
-  // Connection info
-  const connInfo = chalk.green('Connected to ' + service.propfirm.name);
-  const connLen = ('Connected to ' + service.propfirm.name).length;
-  console.log(chalk.cyan('║') + '  ' + connInfo + ' '.repeat(innerWidth - connLen - 2) + chalk.cyan('║'));
+  // Connection info - show all active connections
+  const allConns = connections.getAll();
+  if (allConns.length > 0) {
+    const connNames = allConns.map(c => c.propfirm || c.type).join(', ');
+    const connText = `Connected to ${connNames}`;
+    const connInfo = chalk.green(connText);
+    console.log(chalk.cyan('║') + '  ' + connInfo + ' '.repeat(Math.max(0, innerWidth - connText.length - 2)) + chalk.cyan('║'));
+  }
   
   if (user) {
     const userInfo = 'Welcome, ' + user.userName.toUpperCase() + '!';

package/src/services/rithmic/constants.js

@@ -61,8 +61,8 @@ const REQ = {
   BRACKET_ORDER: 330,
   CANCEL_ALL_ORDERS: 346,
   EXIT_POSITION: 3504,
-  PNL_POSITION_SNAPSHOT: 400,
-  PNL_POSITION_UPDATES: 402,
+  PNL_POSITION_UPDATES: 400,
+  PNL_POSITION_SNAPSHOT: 402,
 };
 
 // Response template IDs
@@ -87,8 +87,8 @@ const RES = {
   BRACKET_ORDER: 331,
   CANCEL_ALL_ORDERS: 347,
   EXIT_POSITION: 3505,
-  PNL_POSITION_SNAPSHOT: 401,
-  PNL_POSITION_UPDATES: 403,
+  PNL_POSITION_UPDATES: 401,
+  PNL_POSITION_SNAPSHOT: 403,
 };
 
 // Streaming template IDs

package/src/services/rithmic/index.js

@@ -5,7 +5,7 @@
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { proto, decodeAccountPnL } = require('./protobuf');
+const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, REQ, RES, STREAM } = require('./constants');
 
 class RithmicService extends EventEmitter {
@@ -18,7 +18,10 @@ class RithmicService extends EventEmitter {
     this.loginInfo = null;
     this.accounts = [];
     this.accountPnL = new Map(); // accountId -> pnl data
+    this.positions = new Map(); // symbol -> position data (from InstrumentPnLPositionUpdate)
+    this.orders = []; // Active orders
     this.user = null;
+    this.credentials = null; // Store for PNL connection
   }
 
   /**
@@ -82,10 +85,37 @@ class RithmicService extends EventEmitter {
           try {
             await this.fetchAccounts();
           } catch (e) {
-            // Accounts fetch failed, but login succeeded
-            console.log('Note: Could not fetch accounts');
+            // Accounts fetch failed, ignore
           }
-          resolve({ success: true });
+          
+          // Create default account if none found
+          if (this.accounts.length === 0) {
+            this.accounts = [{
+              accountId: username,
+              accountName: username,
+              fcmId: data.fcmId,
+              ibId: data.ibId,
+            }];
+          }
+          
+          // Store credentials for PNL connection
+          this.credentials = { username, password };
+          
+          // Format accounts for response
+          const formattedAccounts = this.accounts.map(acc => ({
+            accountId: acc.accountId,
+            accountName: acc.accountName || acc.accountId,
+            balance: this.propfirm.defaultBalance,
+            startingBalance: this.propfirm.defaultBalance,
+            profitAndLoss: 0,
+            status: 0
+          }));
+          
+          resolve({ 
+            success: true, 
+            user: this.user,
+            accounts: formattedAccounts
+          });
         });
 
         this.orderConn.once('loginFailed', (data) => {
@@ -290,6 +320,9 @@ class RithmicService extends EventEmitter {
       case RES.TRADE_ROUTES:
         this.onTradeRoutes(data);
         break;
+      case RES.SHOW_ORDERS:
+        this.onShowOrdersResponse(data);
+        break;
       case STREAM.EXCHANGE_NOTIFICATION:
         this.onExchangeNotification(data);
         break;
@@ -299,6 +332,18 @@ class RithmicService extends EventEmitter {
     }
   }
 
+  onShowOrdersResponse(data) {
+    try {
+      const res = proto.decode('ResponseShowOrders', data);
+      if (res.rpCode?.[0] === '0') {
+        // End of orders list
+        this.emit('ordersReceived');
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+
   /**
    * Handle PNL_PLANT messages
    */
@@ -386,7 +431,37 @@ class RithmicService extends EventEmitter {
   }
 
   onInstrumentPnLUpdate(data) {
-    // Handle instrument-level PnL if needed
+    // Handle instrument-level PnL - this contains position data
+    try {
+      const pos = decodeInstrumentPnL(data);
+      if (pos.symbol && pos.accountId) {
+        const key = `${pos.accountId}:${pos.symbol}:${pos.exchange}`;
+        // Net quantity can come from netQuantity field or calculated from buy/sell
+        const netQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
+        
+        if (netQty !== 0) {
+          // We have an open position
+          this.positions.set(key, {
+            accountId: pos.accountId,
+            symbol: pos.symbol,
+            exchange: pos.exchange || 'CME',
+            quantity: netQty,
+            averagePrice: pos.avgOpenFillPrice || 0,
+            openPnl: parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0),
+            closedPnl: parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0),
+            dayPnl: parseFloat(pos.dayPnl || 0),
+            isSnapshot: pos.isSnapshot || false,
+          });
+        } else {
+          // Position closed
+          this.positions.delete(key);
+        }
+        
+        this.emit('positionUpdate', this.positions.get(key));
+      }
+    } catch (e) {
+      // Ignore decode errors
+    }
   }
 
   onExchangeNotification(data) {
@@ -417,6 +492,133 @@ class RithmicService extends EventEmitter {
     return this.user;
   }
 
+  /**
+   * Get positions via PNL_PLANT
+   * Positions are streamed via InstrumentPnLPositionUpdate (template 450)
+   */
+  async getPositions() {
+    // If PNL connection not established, try to connect
+    if (!this.pnlConn && this.credentials) {
+      await this.connectPnL(this.credentials.username, this.credentials.password);
+      // Request snapshot to populate positions
+      await this.requestPnLSnapshot();
+    }
+    
+    // Return cached positions
+    const positions = Array.from(this.positions.values()).map(pos => ({
+      symbol: pos.symbol,
+      exchange: pos.exchange,
+      quantity: pos.quantity,
+      averagePrice: pos.averagePrice,
+      unrealizedPnl: pos.openPnl,
+      realizedPnl: pos.closedPnl,
+      side: pos.quantity > 0 ? 'LONG' : 'SHORT',
+    }));
+    
+    return { success: true, positions };
+  }
+
+  /**
+   * Get orders via ORDER_PLANT
+   * Uses RequestShowOrders (template 320) -> ResponseShowOrders (template 321)
+   */
+  async getOrders() {
+    if (!this.orderConn || !this.loginInfo) {
+      return { success: true, orders: [] };
+    }
+
+    return new Promise((resolve) => {
+      const orders = [];
+      const timeout = setTimeout(() => {
+        resolve({ success: true, orders });
+      }, 3000);
+
+      // Listen for order notifications
+      const orderHandler = (notification) => {
+        // RithmicOrderNotification contains order details
+        if (notification.orderId) {
+          orders.push({
+            orderId: notification.orderId,
+            symbol: notification.symbol,
+            exchange: notification.exchange,
+            side: notification.transactionType === 1 ? 'BUY' : 'SELL',
+            quantity: notification.quantity,
+            filledQuantity: notification.filledQuantity || 0,
+            price: notification.price,
+            orderType: notification.orderType,
+            status: notification.status,
+          });
+        }
+      };
+
+      this.once('ordersReceived', () => {
+        clearTimeout(timeout);
+        this.removeListener('orderNotification', orderHandler);
+        resolve({ success: true, orders });
+      });
+
+      this.on('orderNotification', orderHandler);
+
+      // Send request
+      try {
+        for (const acc of this.accounts) {
+          this.orderConn.send('RequestShowOrders', {
+            templateId: REQ.SHOW_ORDERS,
+            userMsg: ['HQX'],
+            fcmId: acc.fcmId || this.loginInfo.fcmId,
+            ibId: acc.ibId || this.loginInfo.ibId,
+            accountId: acc.accountId,
+          });
+        }
+      } catch (e) {
+        clearTimeout(timeout);
+        resolve({ success: false, error: e.message, orders: [] });
+      }
+    });
+  }
+
+  /**
+   * Get order history
+   * Uses RequestShowOrderHistorySummary (template 324)
+   */
+  async getOrderHistory(date) {
+    if (!this.orderConn || !this.loginInfo) {
+      return { success: true, orders: [] };
+    }
+
+    // Default to today
+    const dateStr = date || new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    
+    return new Promise((resolve) => {
+      const orders = [];
+      const timeout = setTimeout(() => {
+        resolve({ success: true, orders });
+      }, 3000);
+
+      try {
+        for (const acc of this.accounts) {
+          this.orderConn.send('RequestShowOrderHistorySummary', {
+            templateId: REQ.SHOW_ORDER_HISTORY,
+            userMsg: ['HQX'],
+            fcmId: acc.fcmId || this.loginInfo.fcmId,
+            ibId: acc.ibId || this.loginInfo.ibId,
+            accountId: acc.accountId,
+            date: dateStr,
+          });
+        }
+        
+        // Wait for response
+        setTimeout(() => {
+          clearTimeout(timeout);
+          resolve({ success: true, orders });
+        }, 2000);
+      } catch (e) {
+        clearTimeout(timeout);
+        resolve({ success: false, error: e.message, orders: [] });
+      }
+    });
+  }
+
   /**
    * Check market hours (same as ProjectX)
    */
@@ -477,8 +679,11 @@ class RithmicService extends EventEmitter {
     }
     this.accounts = [];
     this.accountPnL.clear();
+    this.positions.clear();
+    this.orders = [];
     this.loginInfo = null;
     this.user = null;
+    this.credentials = null;
   }
 }
 

package/src/services/rithmic/protobuf.js

@@ -28,6 +28,36 @@ const PNL_FIELDS = {
   USECS: 150101,
 };
 
+// Instrument PnL Position Update field IDs
+const INSTRUMENT_PNL_FIELDS = {
+  TEMPLATE_ID: 154467,
+  IS_SNAPSHOT: 110121,
+  FCM_ID: 154013,
+  IB_ID: 154014,
+  ACCOUNT_ID: 154008,
+  SYMBOL: 110100,
+  EXCHANGE: 110101,
+  PRODUCT_CODE: 100749,
+  INSTRUMENT_TYPE: 110116,
+  FILL_BUY_QTY: 154041,
+  FILL_SELL_QTY: 154042,
+  ORDER_BUY_QTY: 154037,
+  ORDER_SELL_QTY: 154038,
+  BUY_QTY: 154260,
+  SELL_QTY: 154261,
+  AVG_OPEN_FILL_PRICE: 154434,
+  DAY_OPEN_PNL: 157954,
+  DAY_CLOSED_PNL: 157955,
+  DAY_PNL: 157956,
+  OPEN_POSITION_PNL: 156961,
+  OPEN_POSITION_QUANTITY: 156962,
+  CLOSED_POSITION_PNL: 156963,
+  CLOSED_POSITION_QUANTITY: 156964,
+  NET_QUANTITY: 156967,
+  SSBOE: 150100,
+  USECS: 150101,
+};
+
 /**
  * Read a varint from buffer
  */
@@ -158,6 +188,106 @@ function decodeAccountPnL(buffer) {
   return result;
 }
 
+/**
+ * Manually decode InstrumentPnLPositionUpdate from raw bytes
+ */
+function decodeInstrumentPnL(buffer) {
+  const result = {};
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOffset] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case INSTRUMENT_PNL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.IS_SNAPSHOT:
+          const [isSnap, snapOffset] = readVarint(buffer, offset);
+          result.isSnapshot = isSnap !== 0;
+          offset = snapOffset;
+          break;
+        case INSTRUMENT_PNL_FIELDS.FCM_ID:
+          [result.fcmId, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.IB_ID:
+          [result.ibId, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.ACCOUNT_ID:
+          [result.accountId, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SYMBOL:
+          [result.symbol, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.PRODUCT_CODE:
+          [result.productCode, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.BUY_QTY:
+          [result.buyQty, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SELL_QTY:
+          [result.sellQty, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.FILL_BUY_QTY:
+          [result.fillBuyQty, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.FILL_SELL_QTY:
+          [result.fillSellQty, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.NET_QUANTITY:
+          [result.netQuantity, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_QUANTITY:
+          [result.openPositionQuantity, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.AVG_OPEN_FILL_PRICE:
+          // Double is 64-bit fixed
+          if (wireType === 1) {
+            result.avgOpenFillPrice = buffer.readDoubleLE(offset);
+            offset += 8;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_PNL:
+          [result.openPositionPnl, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.CLOSED_POSITION_PNL:
+          [result.closedPositionPnl, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_PNL:
+          [result.dayPnl, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_OPEN_PNL:
+          [result.dayOpenPnl, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_CLOSED_PNL:
+          [result.dayClosedPnl, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SSBOE:
+          [result.ssboe, offset] = readVarint(buffer, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.USECS:
+          [result.usecs, offset] = readVarint(buffer, offset);
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
 /**
  * Protobuf Handler class
  */
@@ -253,6 +383,7 @@ const proto = new ProtobufHandler();
 module.exports = {
   proto,
   decodeAccountPnL,
+  decodeInstrumentPnL,
   readVarint,
   readLengthDelimited,
   skipField,