hedgequantx 1.2.34 → 1.2.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.2.34",
+  "version": "1.2.35",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {
@@ -47,6 +47,7 @@
     "figlet": "^1.7.0",
     "inquirer": "^7.3.3",
     "ora": "^5.4.1",
+    "protobufjs": "^8.0.0",
     "ws": "^8.18.3"
   }
 }

package/src/app.js

@@ -11,7 +11,8 @@ const { execSync } = require('child_process');
 const path = require('path');
 
 const { ProjectXService, connections } = require('./services');
-const { PROPFIRM_CHOICES, getPropFirmsByPlatform } = require('./config');
+const { RithmicService } = require('./services/rithmic');
+const { PROPFIRM_CHOICES, getPropFirmsByPlatform, getPropFirm } = require('./config');
 const { getDevice, getSeparator, printLogo, getLogoWidth, drawBoxHeader, drawBoxFooter, centerText, createBoxMenu } = require('./ui');
 const { validateUsername, validatePassword, maskSensitive } = require('./security');
 
@@ -22,6 +23,7 @@ const { algoTradingMenu } = require('./pages/algo');
 
 // Current service reference
 let currentService = null;
+let currentPlatform = null; // 'projectx' or 'rithmic'
 
 /**
  * Displays the application banner with stats if connected
@@ -257,6 +259,107 @@ const projectXMenu = async () => {
       await service.getUser();
       connections.add('projectx', service, service.propfirm.name);
       currentService = service;
+      currentPlatform = 'projectx';
+      spinner.succeed(`Connected to ${service.propfirm.name}`);
+      return service;
+    } else {
+      spinner.fail(result.error || 'Authentication failed');
+      return null;
+    }
+  } catch (error) {
+    spinner.fail(error.message);
+    return null;
+  }
+};
+
+/**
+ * Rithmic platform connection menu
+ */
+const rithmicMenu = async () => {
+  const propfirms = getPropFirmsByPlatform('Rithmic');
+  const boxWidth = getLogoWidth();
+  const innerWidth = boxWidth - 2;
+  const numCols = 3;
+  const colWidth = Math.floor(innerWidth / numCols);
+  
+  // Build numbered list
+  const numbered = propfirms.map((pf, i) => ({
+    num: i + 1,
+    key: pf.key,
+    name: pf.displayName,
+    systemName: pf.rithmicSystem
+  }));
+  
+  // PropFirm selection box
+  console.log();
+  console.log(chalk.cyan('╔' + '═'.repeat(innerWidth) + '╗'));
+  console.log(chalk.cyan('║') + chalk.white.bold(centerText('SELECT PROPFIRM (RITHMIC)', innerWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
+  
+  // Display in 3 columns with fixed width alignment
+  const rows = Math.ceil(numbered.length / numCols);
+  
+  for (let row = 0; row < rows; row++) {
+    let line = '';
+    for (let col = 0; col < numCols; col++) {
+      const idx = row + col * rows;
+      if (idx < numbered.length) {
+        const item = numbered[idx];
+        const numStr = item.num.toString().padStart(2, ' ');
+        const coloredText = chalk.cyan(`[${numStr}]`) + ' ' + chalk.white(item.name);
+        const textLen = 4 + 1 + item.name.length;
+        const padding = colWidth - textLen - 2;
+        line += '  ' + coloredText + ' '.repeat(Math.max(0, padding));
+      } else {
+        line += ' '.repeat(colWidth);
+      }
+    }
+    const lineLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const adjust = innerWidth - lineLen;
+    console.log(chalk.cyan('║') + line + ' '.repeat(Math.max(0, adjust)) + chalk.cyan('║'));
+  }
+  
+  console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
+  const backText = '  ' + chalk.red('[X] Back');
+  const backLen = '[X] Back'.length + 2;
+  console.log(chalk.cyan('║') + backText + ' '.repeat(innerWidth - backLen) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
+  console.log();
+
+  const validInputs = numbered.map(n => n.num.toString());
+  validInputs.push('x', 'X');
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'action',
+      message: chalk.cyan(`Enter choice (1-${numbered.length}/X):`),
+      validate: (input) => {
+        if (validInputs.includes(input)) return true;
+        return `Please enter 1-${numbered.length} or X`;
+      }
+    }
+  ]);
+
+  if (action.toLowerCase() === 'x') return null;
+  
+  const selectedIdx = parseInt(action) - 1;
+  const selectedPropfirm = numbered[selectedIdx];
+
+  const credentials = await loginPrompt(selectedPropfirm.name);
+  const spinner = ora('Connecting to Rithmic...').start();
+
+  try {
+    const service = new RithmicService(selectedPropfirm.key);
+    const result = await service.login(credentials.username, credentials.password);
+
+    if (result.success) {
+      spinner.text = 'Fetching accounts...';
+      await service.getTradingAccounts();
+      
+      connections.add('rithmic', service, service.propfirm.name);
+      currentService = service;
+      currentPlatform = 'rithmic';
       spinner.succeed(`Connected to ${service.propfirm.name}`);
       return service;
     } else {
@@ -294,7 +397,7 @@ const mainMenu = async () => {
     console.log(chalk.cyan('║') + leftText + ' '.repeat(Math.max(0, leftPad)) + rightText + ' '.repeat(Math.max(0, rightPad)) + chalk.cyan('║'));
   };
   
-  menuRow(chalk.cyan('[1] ProjectX'), chalk.gray('[2] Rithmic (Coming Soon)'));
+  menuRow(chalk.cyan('[1] ProjectX'), chalk.cyan('[2] Rithmic'));
   menuRow(chalk.gray('[3] Tradovate (Coming Soon)'), chalk.red('[X] Exit'));
   
   console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
@@ -304,11 +407,11 @@ const mainMenu = async () => {
     {
       type: 'input',
       name: 'action',
-      message: chalk.cyan('Enter choice (1/X):'),
+      message: chalk.cyan('Enter choice (1/2/X):'),
       validate: (input) => {
-        const valid = ['1', 'x', 'X'];
+        const valid = ['1', '2', 'x', 'X'];
         if (valid.includes(input)) return true;
-        return 'Please enter 1 or X';
+        return 'Please enter 1, 2 or X';
       }
     }
   ]);
@@ -316,6 +419,7 @@ const mainMenu = async () => {
   // Map input to action
   const actionMap = {
     '1': 'projectx',
+    '2': 'rithmic',
     'x': 'exit',
     'X': 'exit'
   };
@@ -512,6 +616,11 @@ const run = async () => {
         const service = await projectXMenu();
         if (service) currentService = service;
       }
+      
+      if (choice === 'rithmic') {
+        const service = await rithmicMenu();
+        if (service) currentService = service;
+      }
     } else {
       const action = await dashboardMenu(currentService);
       

package/src/services/rithmic/connection.js

@@ -0,0 +1,203 @@
+/**
+ * Rithmic Connection Manager
+ * Handles WebSocket connection and heartbeat
+ */
+
+const WebSocket = require('ws');
+const EventEmitter = require('events');
+const { proto } = require('./protobuf');
+const { REQ, RES, INFRA_TYPE } = require('./constants');
+
+class RithmicConnection extends EventEmitter {
+  constructor() {
+    super();
+    this.ws = null;
+    this.config = null;
+    this.state = 'DISCONNECTED';
+    this.heartbeatTimer = null;
+  }
+
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  get connectionState() {
+    return this.state;
+  }
+
+  /**
+   * Connect to Rithmic server
+   */
+  async connect(config) {
+    this.config = config;
+    this.state = 'CONNECTING';
+
+    await proto.load();
+
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(config.uri, { rejectUnauthorized: false });
+
+      this.ws.on('open', () => {
+        this.state = 'CONNECTED';
+        this.emit('connected');
+        resolve(true);
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleMessage(data);
+      });
+
+      this.ws.on('error', (err) => {
+        this.state = 'ERROR';
+        this.emit('error', err);
+        reject(err);
+      });
+
+      this.ws.on('close', (code, reason) => {
+        this.state = 'DISCONNECTED';
+        this.stopHeartbeat();
+        this.emit('disconnected', { code, reason: reason?.toString() });
+      });
+
+      // Timeout
+      setTimeout(() => {
+        if (this.state === 'CONNECTING') {
+          reject(new Error('Connection timeout'));
+        }
+      }, 15000);
+    });
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    this.stopHeartbeat();
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.send('RequestLogout', { templateId: REQ.LOGOUT, userMsg: ['HQX'] });
+      this.ws.close(1000, 'bye');
+    }
+    this.ws = null;
+    this.state = 'DISCONNECTED';
+  }
+
+  /**
+   * Send a protobuf message
+   */
+  send(typeName, data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected');
+    }
+    const buffer = proto.encode(typeName, data);
+    this.ws.send(buffer);
+  }
+
+  /**
+   * Login to system
+   */
+  login(infraType = 'ORDER_PLANT') {
+    if (!this.config) throw new Error('No config');
+
+    this.send('RequestLogin', {
+      templateId: REQ.LOGIN,
+      templateVersion: '3.9',
+      userMsg: ['HQX'],
+      user: this.config.userId,
+      password: this.config.password,
+      appName: this.config.appName || 'HQX-CLI',
+      appVersion: this.config.appVersion || '1.0.0',
+      systemName: this.config.systemName,
+      infraType: INFRA_TYPE[infraType],
+    });
+  }
+
+  /**
+   * List available systems
+   */
+  listSystems() {
+    this.send('RequestRithmicSystemInfo', {
+      templateId: REQ.SYSTEM_INFO,
+      userMsg: ['HQX'],
+    });
+  }
+
+  /**
+   * Handle incoming message
+   */
+  handleMessage(data) {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const templateId = proto.getTemplateId(buffer);
+
+    switch (templateId) {
+      case RES.LOGIN:
+        this.onLoginResponse(buffer);
+        break;
+
+      case RES.HEARTBEAT:
+        // OK
+        break;
+
+      case RES.SYSTEM_INFO:
+        this.onSystemInfo(buffer);
+        break;
+
+      default:
+        // Forward to listeners
+        this.emit('message', { templateId, data: buffer });
+    }
+  }
+
+  onLoginResponse(data) {
+    try {
+      const res = proto.decode('ResponseLogin', data);
+
+      if (res.rpCode?.[0] === '0') {
+        this.state = 'LOGGED_IN';
+        this.startHeartbeat(res.heartbeatInterval || 60);
+        this.emit('loggedIn', {
+          fcmId: res.fcmId,
+          ibId: res.ibId,
+          heartbeatInterval: res.heartbeatInterval,
+        });
+      } else {
+        const errorCode = res.rpCode?.[0] || 'UNKNOWN';
+        const errorMsg = res.rpCode?.[1] || 'Login failed';
+        this.emit('loginFailed', { code: errorCode, message: errorMsg });
+      }
+    } catch (e) {
+      this.emit('loginFailed', { code: 'DECODE_ERROR', message: e.message });
+    }
+  }
+
+  onSystemInfo(data) {
+    try {
+      const res = proto.decode('ResponseRithmicSystemInfo', data);
+
+      if (res.rpCode?.[0] === '0') {
+        this.emit('systems', res.systemName || []);
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  startHeartbeat(intervalSec) {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      try {
+        this.send('RequestHeartbeat', { templateId: REQ.HEARTBEAT });
+      } catch (e) {
+        // Ignore
+      }
+    }, (intervalSec - 5) * 1000);
+  }
+
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+}
+
+module.exports = { RithmicConnection };

package/src/services/rithmic/constants.js

@@ -0,0 +1,156 @@
+/**
+ * Rithmic Constants
+ */
+
+// Endpoints
+const RITHMIC_ENDPOINTS = {
+  TEST: 'wss://rituz00100.rithmic.com:443',
+  PAPER: 'wss://ritpa11120.11.rithmic.com:443',
+  LIVE: 'wss://ritpz01000.01.rithmic.com:443',
+};
+
+// System names for PropFirms
+const RITHMIC_SYSTEMS = {
+  TEST: 'Rithmic Test',
+  PAPER: 'Rithmic Paper Trading',
+  APEX: 'Apex',
+  TOPSTEP: 'TopstepTrader',
+  MES_CAPITAL: 'MES Capital',
+  BULENOX: 'Bulenox',
+  TRADEFUNDRR: 'TradeFundrr',
+  THE_TRADING_PIT: 'TheTradingPit',
+  FUNDED_FUTURES_NETWORK: 'FundedFuturesNetwork',
+  PROPSHOP_TRADER: 'PropShopTrader',
+  FOUR_PROP_TRADER: '4PropTrader',
+  DAY_TRADERS: 'DayTraders.com',
+  TEN_X_FUTURES: '10XFutures',
+  LUCID_TRADING: 'LucidTrading',
+  THRIVE_TRADING: 'ThriveTrading',
+  LEGENDS_TRADING: 'LegendsTrading',
+  EARN_2_TRADE: 'Earn2Trade',
+};
+
+// Infrastructure types
+const INFRA_TYPE = {
+  TICKER_PLANT: 1,
+  ORDER_PLANT: 2,
+  HISTORY_PLANT: 3,
+  PNL_PLANT: 4,
+  REPOSITORY_PLANT: 5,
+};
+
+// Request template IDs
+const REQ = {
+  LOGIN: 10,
+  LOGOUT: 12,
+  SYSTEM_INFO: 16,
+  HEARTBEAT: 18,
+  MARKET_DATA: 100,
+  LOGIN_INFO: 300,
+  ACCOUNT_LIST: 302,
+  ACCOUNT_RMS: 304,
+  PRODUCT_RMS: 306,
+  ORDER_UPDATES: 308,
+  TRADE_ROUTES: 310,
+  NEW_ORDER: 312,
+  MODIFY_ORDER: 314,
+  CANCEL_ORDER: 316,
+  SHOW_ORDER_HISTORY_DATES: 318,
+  SHOW_ORDERS: 320,
+  SHOW_ORDER_HISTORY: 324,
+  BRACKET_ORDER: 330,
+  CANCEL_ALL_ORDERS: 346,
+  EXIT_POSITION: 3504,
+  PNL_POSITION_SNAPSHOT: 400,
+  PNL_POSITION_UPDATES: 402,
+};
+
+// Response template IDs
+const RES = {
+  LOGIN: 11,
+  LOGOUT: 13,
+  SYSTEM_INFO: 17,
+  HEARTBEAT: 19,
+  MARKET_DATA: 101,
+  LOGIN_INFO: 301,
+  ACCOUNT_LIST: 303,
+  ACCOUNT_RMS: 305,
+  PRODUCT_RMS: 307,
+  ORDER_UPDATES: 309,
+  TRADE_ROUTES: 311,
+  NEW_ORDER: 313,
+  MODIFY_ORDER: 315,
+  CANCEL_ORDER: 317,
+  SHOW_ORDER_HISTORY_DATES: 319,
+  SHOW_ORDERS: 321,
+  SHOW_ORDER_HISTORY: 325,
+  BRACKET_ORDER: 331,
+  CANCEL_ALL_ORDERS: 347,
+  EXIT_POSITION: 3505,
+  PNL_POSITION_SNAPSHOT: 401,
+  PNL_POSITION_UPDATES: 403,
+};
+
+// Streaming template IDs
+const STREAM = {
+  LAST_TRADE: 150,
+  BBO: 151,
+  TRADE_ROUTE_UPDATE: 350,
+  ORDER_NOTIFICATION: 351,
+  EXCHANGE_NOTIFICATION: 352,
+  BRACKET_UPDATE: 353,
+  INSTRUMENT_PNL_UPDATE: 450,
+  ACCOUNT_PNL_UPDATE: 451,
+};
+
+// Proto files to load
+const PROTO_FILES = [
+  'base.proto',
+  'request_heartbeat.proto',
+  'response_heartbeat.proto',
+  'request_rithmic_system_info.proto',
+  'response_rithmic_system_info.proto',
+  'request_login.proto',
+  'response_login.proto',
+  'request_logout.proto',
+  'response_logout.proto',
+  'request_login_info.proto',
+  'response_login_info.proto',
+  'request_account_list.proto',
+  'response_account_list.proto',
+  'request_trade_routes.proto',
+  'response_trade_routes.proto',
+  'request_subscribe_for_order_updates.proto',
+  'response_subscribe_for_order_updates.proto',
+  'request_new_order.proto',
+  'response_new_order.proto',
+  'request_cancel_all_orders.proto',
+  'rithmic_order_notification.proto',
+  'exchange_order_notification.proto',
+  'request_show_orders.proto',
+  'response_show_orders.proto',
+  'request_show_order_history.proto',
+  'response_show_order_history.proto',
+  'request_show_order_history_dates.proto',
+  'response_show_order_history_dates.proto',
+  'request_market_data_update.proto',
+  'response_market_data_update.proto',
+  'last_trade.proto',
+  'best_bid_offer.proto',
+  'request_pnl_position_snapshot.proto',
+  'response_pnl_position_snapshot.proto',
+  'request_pnl_position_updates.proto',
+  'response_pnl_position_updates.proto',
+  'account_pnl_position_update.proto',
+  'instrument_pnl_position_update.proto',
+];
+
+module.exports = {
+  RITHMIC_ENDPOINTS,
+  RITHMIC_SYSTEMS,
+  INFRA_TYPE,
+  REQ,
+  RES,
+  STREAM,
+  PROTO_FILES,
+};