hedgequantx 2.7.15 → 2.7.17

package/src/menus/dashboard.js

@@ -30,8 +30,8 @@ const dashboardMenu = async (service) => {
     return chalk.cyan('║') + content + ' '.repeat(Math.max(0, padding)) + chalk.cyan('║');
   };
   
-  // Continue from banner (use ╠ not ╔)
-  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  // New box for dashboard menu
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
   console.log(makeLine(chalk.yellow.bold('Welcome, HQX Trader!'), 'center'));
   console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
   
@@ -89,7 +89,8 @@ const dashboardMenu = async (service) => {
   const menuItems = [
     { left: '[1] View Accounts', right: '[2] View Stats' },
     { left: '[+] Add Prop-Account', right: '[A] Algo-Trading' },
-    { left: '[U] Update HQX', right: '[X] Disconnect' },
+    { left: '[I] AI Agents', right: '[U] Update HQX' },
+    { left: '', right: '[X] Disconnect' },
   ];
   
   const maxLeftLen = Math.max(...menuItems.map(m => m.left.length));
@@ -121,18 +122,20 @@ const dashboardMenu = async (service) => {
   
   menuRow('[1] View Accounts', '[2] View Stats', chalk.cyan, chalk.cyan);
   menuRow('[+] Add Prop-Account', '[A] Algo-Trading', chalk.cyan, chalk.magenta);
-  menuRow('[U] Update HQX', '[X] Disconnect', chalk.yellow, chalk.red);
+  menuRow('[I] AI Agents', '[U] Update HQX', chalk.green, chalk.yellow);
+  menuRow('', '[X] Disconnect', chalk.white, chalk.red);
   
   console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
   
   // Simple input - no duplicate menu
-  const input = await prompts.textInput(chalk.cyan('Select (1/2/+/A/U/X)'));
+  const input = await prompts.textInput(chalk.cyan('Select (1/2/+/A/I/U/X)'));
   
   const actionMap = {
     '1': 'accounts',
     '2': 'stats',
     '+': 'add_prop_account',
     'a': 'algotrading',
+    'i': 'aiagents',
     'u': 'update',
     'x': 'disconnect'
   };

package/src/lib/api.js

@@ -1,198 +0,0 @@
-/**
- * Trading API - REAL ORDER EXECUTION
- * Connects to ProjectX/TopstepX API for real trades
- */
-
-const https = require('https');
-
-const PROPFIRM_APIS = {
-  topstep: 'api.topstepx.com',
-  alpha_futures: 'api.alphafutures.projectx.com',
-  tickticktrader: 'api.tickticktrader.projectx.com',
-  bulenox: 'api.bulenox.projectx.com',
-  tradeday: 'api.tradeday.projectx.com'
-};
-
-class TradingAPI {
-  constructor(token, propfirm = 'topstep') {
-    this.token = token;
-    this.apiHost = PROPFIRM_APIS[propfirm] || PROPFIRM_APIS.topstep;
-  }
-
-  async _request(path, method = 'POST', data = null) {
-    return new Promise((resolve, reject) => {
-      const options = {
-        hostname: this.apiHost,
-        port: 443,
-        path: path,
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json',
-          'Authorization': `Bearer ${this.token}`
-        },
-        timeout: 10000
-      };
-
-      const req = https.request(options, (res) => {
-        let body = '';
-        res.on('data', chunk => body += chunk);
-        res.on('end', () => {
-          try {
-            resolve({ status: res.statusCode, data: JSON.parse(body) });
-          } catch (e) {
-            resolve({ status: res.statusCode, data: body });
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
-
-      if (data) req.write(JSON.stringify(data));
-      req.end();
-    });
-  }
-
-  /**
-   * Place a market order - REAL EXECUTION
-   * ProjectX API order types:
-   *   1 = Limit (requires limitPrice)
-   *   2 = Market (no price required)
-   *   3 = Stop Market (requires stopPrice)
-   *   4 = Stop Limit (requires both)
-   */
-  async placeMarketOrder(accountId, contractId, side, quantity, currentPrice = 0) {
-    // Type 2 = Market order - tested and confirmed working
-    const orderData = {
-      accountId: parseInt(accountId),
-      contractId: contractId,
-      type: 2, // Market order
-      side: side === 'buy' ? 0 : 1, // 0=Buy, 1=Sell
-      size: quantity
-    };
-
-    console.log(`[TRADING] MARKET ${side.toUpperCase()} ${quantity}x ${contractId}`);
-    
-    const response = await this._request('/api/Order/place', 'POST', orderData);
-    
-    if (response.status === 200 && response.data.success) {
-      console.log(`[TRADING] FILLED - OrderId: ${response.data.orderId}`);
-      return { success: true, order: response.data };
-    } else {
-      console.log(`[TRADING] REJECTED: ${response.data.errorMessage || 'Unknown error'}`);
-      return { success: false, error: response.data.errorMessage || 'Order failed' };
-    }
-  }
-
-  /**
-   * Place a limit order - REAL EXECUTION
-   */
-  async placeLimitOrder(accountId, contractId, side, quantity, price) {
-    const orderData = {
-      accountId: parseInt(accountId),
-      contractId: contractId,
-      type: 0, // Limit order
-      side: side === 'buy' ? 0 : 1,
-      size: quantity,
-      limitPrice: price
-    };
-
-    console.log(`[TRADING] Placing LIMIT order: ${side.toUpperCase()} ${quantity}x ${contractId} @ ${price}`);
-    
-    const response = await this._request('/api/Order/place', 'POST', orderData);
-    
-    if (response.status === 200 && response.data.success) {
-      console.log(`[TRADING] Limit order placed: ${JSON.stringify(response.data)}`);
-      return { success: true, order: response.data };
-    } else {
-      return { success: false, error: response.data.errorMessage || 'Order failed' };
-    }
-  }
-
-  /**
-   * Place a stop order - REAL EXECUTION
-   * ProjectX API: type 2 = Stop Market
-   */
-  async placeStopOrder(accountId, contractId, side, quantity, stopPrice) {
-    const orderData = {
-      accountId: parseInt(accountId),
-      contractId: contractId,
-      type: 2, // Stop Market order
-      side: side === 'buy' ? 0 : 1,
-      size: quantity,
-      stopPrice: stopPrice
-    };
-
-    console.log(`[TRADING] Placing STOP order: ${side.toUpperCase()} ${quantity}x ${contractId} @ stop ${stopPrice}`);
-    
-    const response = await this._request('/api/Order/place', 'POST', orderData);
-    
-    console.log(`[TRADING] Stop response: ${JSON.stringify(response.data)}`);
-    
-    if (response.status === 200 && response.data.success) {
-      console.log(`[TRADING] Stop order placed - OrderId: ${response.data.orderId}`);
-      return { success: true, order: response.data };
-    } else {
-      console.log(`[TRADING] Stop order REJECTED: ${response.data.errorMessage || 'Unknown error'}`);
-      return { success: false, error: response.data.errorMessage || 'Order failed' };
-    }
-  }
-
-  /**
-   * Cancel an order
-   */
-  async cancelOrder(orderId) {
-    const response = await this._request('/api/Order/cancel', 'POST', { orderId: parseInt(orderId) });
-    return { success: response.status === 200 && response.data.success };
-  }
-
-  /**
-   * Close a position - REAL EXECUTION
-   */
-  async closePosition(accountId, contractId) {
-    console.log(`[TRADING] Closing position: ${contractId}`);
-    
-    const response = await this._request('/api/Position/closeContract', 'POST', {
-      accountId: parseInt(accountId),
-      contractId: contractId
-    });
-
-    if (response.status === 200 && response.data.success) {
-      console.log(`[TRADING] Position CLOSED`);
-      return { success: true };
-    } else {
-      console.log(`[TRADING] Close FAILED: ${JSON.stringify(response.data)}`);
-      return { success: false, error: response.data.errorMessage || 'Close failed' };
-    }
-  }
-
-  /**
-   * Get open positions
-   */
-  async getPositions(accountId) {
-    const response = await this._request('/api/Position/searchOpen', 'POST', { accountId: parseInt(accountId) });
-    
-    if (response.status === 200) {
-      return { success: true, positions: response.data.positions || response.data || [] };
-    }
-    return { success: false, positions: [] };
-  }
-
-  /**
-   * Get open orders
-   */
-  async getOrders(accountId) {
-    const response = await this._request('/api/Order/searchOpen', 'POST', { accountId: parseInt(accountId) });
-    
-    if (response.status === 200) {
-      return { success: true, orders: response.data.orders || response.data || [] };
-    }
-    return { success: false, orders: [] };
-  }
-}
-
-module.exports = { TradingAPI };

package/src/lib/api2.js

@@ -1,353 +0,0 @@
-/**
- * Rithmic Trading API - REAL ORDER EXECUTION
- * Connects to Rithmic via WebSocket/Protobuf for order execution
- */
-
-const WebSocket = require('ws');
-const protobuf = require('protobufjs');
-const path = require('path');
-
-const RITHMIC_GATEWAYS = {
-  CHICAGO: 'wss://rprotocol.rithmic.com:443',
-  EUROPE: 'wss://rprotocol-ie.rithmic.com:443',
-  TEST: 'wss://rituz00100.rithmic.com:443'
-};
-
-const PROTO_PATH = path.join(__dirname, '../../protos/rithmic');
-
-class RithmicTradingAPI {
-  constructor(config) {
-    this.config = config;
-    this.ws = null;
-    this.isConnected = false;
-    this.protoRoot = null;
-    this.pendingOrders = new Map();
-    this.orderIdCounter = 1;
-    
-    // Proto message types
-    this.RequestLogin = null;
-    this.ResponseLogin = null;
-    this.RequestNewOrder = null;
-    this.ResponseNewOrder = null;
-    this.ExchangeOrderNotification = null;
-  }
-
-  /**
-   * Load protobuf definitions
-   */
-  async _loadProtos() {
-    if (this.protoRoot) return;
-    
-    try {
-      this.protoRoot = await protobuf.load([
-        path.join(PROTO_PATH, 'request_login.proto'),
-        path.join(PROTO_PATH, 'response_login.proto'),
-        path.join(PROTO_PATH, 'request_new_order.proto'),
-        path.join(PROTO_PATH, 'response_new_order.proto'),
-        path.join(PROTO_PATH, 'exchange_order_notification.proto'),
-        path.join(PROTO_PATH, 'request_cancel_all_orders.proto'),
-        path.join(PROTO_PATH, 'request_heartbeat.proto'),
-        path.join(PROTO_PATH, 'response_heartbeat.proto')
-      ]);
-      
-      this.RequestLogin = this.protoRoot.lookupType('rti.RequestLogin');
-      this.ResponseLogin = this.protoRoot.lookupType('rti.ResponseLogin');
-      this.RequestNewOrder = this.protoRoot.lookupType('rti.RequestNewOrder');
-      this.ResponseNewOrder = this.protoRoot.lookupType('rti.ResponseNewOrder');
-      this.ExchangeOrderNotification = this.protoRoot.lookupType('rti.ExchangeOrderNotification');
-      this.RequestCancelAllOrders = this.protoRoot.lookupType('rti.RequestCancelAllOrders');
-      this.RequestHeartbeat = this.protoRoot.lookupType('rti.RequestHeartbeat');
-      
-      console.log('[RITHMIC-TRADE] Protos loaded');
-    } catch (error) {
-      console.error('[RITHMIC-TRADE] Failed to load protos:', error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Connect to Rithmic ORDER_PLANT for trading
-   */
-  async connect() {
-    if (this.isConnected) return true;
-    
-    await this._loadProtos();
-    
-    const { userId, password, systemName, gateway } = this.config;
-    const gatewayUrl = gateway || RITHMIC_GATEWAYS.CHICAGO;
-    
-    console.log(`[RITHMIC-TRADE] Connecting to ${gatewayUrl} for order execution`);
-    
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(gatewayUrl, { rejectUnauthorized: false });
-      
-      const timeout = setTimeout(() => {
-        this.ws.close();
-        reject(new Error('Connection timeout'));
-      }, 15000);
-      
-      this.ws.on('open', async () => {
-        console.log('[RITHMIC-TRADE] WebSocket connected, sending login...');
-        
-        const loginRequest = this.RequestLogin.create({
-          templateId: 10,
-          templateVersion: '3.9',
-          user: userId,
-          password: password,
-          appName: 'App',
-          appVersion: '1.0.0',
-          systemName: systemName,
-          infraType: 2 // ORDER_PLANT for trading
-        });
-        
-        const buffer = this.RequestLogin.encode(loginRequest).finish();
-        this.ws.send(buffer);
-      });
-      
-      this.ws.on('message', (data) => {
-        this._handleMessage(data, (success, error) => {
-          if (success !== undefined) {
-            clearTimeout(timeout);
-            if (success) {
-              this.isConnected = true;
-              this._startHeartbeat();
-              resolve(true);
-            } else {
-              reject(new Error(error || 'Login failed'));
-            }
-          }
-        });
-      });
-      
-      this.ws.on('error', (error) => {
-        console.error('[RITHMIC-TRADE] Error:', error.message);
-        clearTimeout(timeout);
-        reject(error);
-      });
-      
-      this.ws.on('close', () => {
-        this.isConnected = false;
-        this._stopHeartbeat();
-      });
-    });
-  }
-
-  /**
-   * Handle incoming message
-   */
-  _handleMessage(data, loginCallback) {
-    try {
-      const buffer = new Uint8Array(data);
-      
-      // Try ResponseLogin
-      try {
-        const response = this.ResponseLogin.decode(buffer);
-        if (response.templateId === 11) {
-          const rpCode = Array.isArray(response.rpCode) ? response.rpCode[0] : response.rpCode;
-          if (rpCode === '0') {
-            console.log('[RITHMIC-TRADE] Login successful');
-            loginCallback(true);
-          } else {
-            console.log(`[RITHMIC-TRADE] Login failed: ${response.textMsg || rpCode}`);
-            loginCallback(false, response.textMsg);
-          }
-          return;
-        }
-      } catch (e) {}
-      
-      // Try ResponseNewOrder
-      try {
-        const response = this.ResponseNewOrder.decode(buffer);
-        if (response.templateId === 313) {
-          this._handleOrderResponse(response);
-          return;
-        }
-      } catch (e) {}
-      
-      // Try ExchangeOrderNotification (fill, reject, etc.)
-      try {
-        const notification = this.ExchangeOrderNotification.decode(buffer);
-        if (notification.templateId === 351) {
-          this._handleOrderNotification(notification);
-          return;
-        }
-      } catch (e) {}
-      
-    } catch (error) {
-      console.error('[RITHMIC-TRADE] Message decode error:', error.message);
-    }
-  }
-
-  /**
-   * Handle order response
-   */
-  _handleOrderResponse(response) {
-    const basketId = response.basketId;
-    const pending = this.pendingOrders.get(basketId);
-    
-    if (pending) {
-      const rpCode = Array.isArray(response.rpCode) ? response.rpCode[0] : response.rpCode;
-      if (rpCode === '0') {
-        console.log(`[RITHMIC-TRADE] Order acknowledged: ${basketId}`);
-        pending.resolve({ success: true, basketId });
-      } else {
-        console.log(`[RITHMIC-TRADE] Order rejected: ${response.textMsg || rpCode}`);
-        pending.reject(new Error(response.textMsg || 'Order rejected'));
-      }
-      this.pendingOrders.delete(basketId);
-    }
-  }
-
-  /**
-   * Handle order notification (fill, cancel, etc.)
-   */
-  _handleOrderNotification(notification) {
-    const status = notification.notifyType;
-    const symbol = notification.symbol;
-    const fillPrice = notification.avgFillPrice;
-    const filledQty = notification.filledQty;
-    
-    console.log(`[RITHMIC-TRADE] Order notification: ${symbol} - Status: ${status}, Filled: ${filledQty} @ ${fillPrice}`);
-  }
-
-  /**
-   * Place a market order - REAL EXECUTION
-   */
-  async placeMarketOrder(accountId, contractId, side, quantity) {
-    if (!this.isConnected) {
-      await this.connect();
-    }
-    
-    const basketId = `X_${Date.now()}_${this.orderIdCounter++}`;
-    
-    // Extract symbol from contractId (e.g., "MNQH5" or just use as-is)
-    const symbol = this._extractSymbol(contractId);
-    
-    const orderRequest = this.RequestNewOrder.create({
-      templateId: 312,
-      userMsg: [basketId],
-      symbol: symbol,
-      exchange: 'CME',
-      quantity: quantity,
-      price: 0,
-      triggerPrice: 0,
-      transactionType: side === 'buy' ? 1 : 2, // 1=Buy, 2=Sell
-      duration: 1, // DAY
-      priceType: 1, // Market
-      tradeRoute: 'DEFAULT',
-      accountId: accountId.toString(),
-      basketId: basketId
-    });
-    
-    console.log(`[RITHMIC-TRADE] MARKET ${side.toUpperCase()} ${quantity}x ${symbol}`);
-    
-    return new Promise((resolve, reject) => {
-      this.pendingOrders.set(basketId, { resolve, reject });
-      
-      const buffer = this.RequestNewOrder.encode(orderRequest).finish();
-      this.ws.send(buffer);
-      
-      // Timeout after 10 seconds
-      setTimeout(() => {
-        if (this.pendingOrders.has(basketId)) {
-          this.pendingOrders.delete(basketId);
-          reject(new Error('Order timeout'));
-        }
-      }, 10000);
-    });
-  }
-
-  /**
-   * Close position - REAL EXECUTION
-   */
-  async closePosition(accountId, contractId) {
-    // For Rithmic, closing a position means placing an opposite order
-    // We need to get the current position first, but for simplicity,
-    // we'll use cancel all and let the caller handle the close order
-    console.log(`[RITHMIC-TRADE] Close position requested: ${contractId}`);
-    
-    // Cancel all pending orders first
-    try {
-      await this.cancelAllOrders(accountId);
-    } catch (e) {
-      console.log('[RITHMIC-TRADE] Cancel all orders failed:', e.message);
-    }
-    
-    return { success: true };
-  }
-
-  /**
-   * Cancel all orders
-   */
-  async cancelAllOrders(accountId) {
-    if (!this.isConnected) return { success: false };
-    
-    const request = this.RequestCancelAllOrders.create({
-      templateId: 316,
-      accountId: accountId.toString()
-    });
-    
-    const buffer = this.RequestCancelAllOrders.encode(request).finish();
-    this.ws.send(buffer);
-    
-    console.log('[RITHMIC-TRADE] Cancel all orders sent');
-    return { success: true };
-  }
-
-  /**
-   * Extract symbol from various formats
-   */
-  _extractSymbol(contractId) {
-    if (!contractId) return 'MNQH5';
-    
-    // If already looks like Rithmic symbol, return as-is
-    if (/^[A-Z]{2,4}[FGHJKMNQUVXZ]\d{1,2}$/.test(contractId)) {
-      return contractId;
-    }
-    
-    // Try to extract from longer format
-    const match = contractId.match(/([A-Z]{2,4})([FGHJKMNQUVXZ])(\d{1,2})/);
-    if (match) {
-      return `${match[1]}${match[2]}${match[3]}`;
-    }
-    
-    return contractId;
-  }
-
-  /**
-   * Start heartbeat
-   */
-  _startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      if (this.isConnected && this.ws) {
-        const heartbeat = this.RequestHeartbeat.create({ templateId: 18 });
-        const buffer = this.RequestHeartbeat.encode(heartbeat).finish();
-        this.ws.send(buffer);
-      }
-    }, 30000);
-  }
-
-  /**
-   * Stop heartbeat
-   */
-  _stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-
-  /**
-   * Disconnect
-   */
-  disconnect() {
-    this._stopHeartbeat();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.isConnected = false;
-  }
-}
-
-module.exports = { RithmicTradingAPI, RITHMIC_GATEWAYS };