hedgequantx 1.1.1

package/src/services/projectx.js

@@ -0,0 +1,369 @@
+/**
+ * ProjectX API Service
+ * Handles all API communication with PropFirm platforms
+ */
+
+const https = require('https');
+const { PROPFIRMS } = require('../config');
+
+class ProjectXService {
+  constructor(propfirmKey = 'topstep') {
+    this.propfirm = PROPFIRMS[propfirmKey] || PROPFIRMS.topstep;
+    this.token = null;
+    this.user = null;
+  }
+
+  /**
+   * Make HTTPS request
+   */
+  async _request(host, path, method = 'GET', data = null) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: host,
+        port: 443,
+        path: path,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        }
+      };
+
+      if (this.token) {
+        options.headers['Authorization'] = `Bearer ${this.token}`;
+      }
+
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve({ statusCode: res.statusCode, data: JSON.parse(body) });
+          } catch (e) {
+            resolve({ statusCode: res.statusCode, data: body });
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(10000, () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (data) req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
+  // ==================== AUTH ====================
+
+  async login(userName, password) {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/Login', 'POST', { userName, password });
+      if (response.statusCode === 200 && response.data.token) {
+        this.token = response.data.token;
+        return { success: true, token: this.token };
+      }
+      return { success: false, error: response.data.errorMessage || 'Invalid credentials' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async loginWithApiKey(userName, apiKey) {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/Login/key', 'POST', { userName, apiKey });
+      if (response.statusCode === 200 && response.data.token) {
+        this.token = response.data.token;
+        return { success: true, token: this.token };
+      }
+      return { success: false, error: response.data.errorMessage || 'Invalid API key' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  logout() {
+    this.token = null;
+    this.user = null;
+  }
+
+  // ==================== USER ====================
+
+  async getUser() {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/User', 'GET');
+      if (response.statusCode === 200) {
+        this.user = response.data;
+        return { success: true, user: response.data };
+      }
+      return { success: false, error: 'Failed to get user info' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // ==================== ACCOUNTS ====================
+
+  async getTradingAccounts() {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/TradingAccount', 'GET');
+      if (response.statusCode === 200) {
+        const accounts = Array.isArray(response.data) ? response.data : [];
+        return { success: true, accounts };
+      }
+      return { success: false, accounts: [], error: 'Failed to get accounts' };
+    } catch (error) {
+      return { success: false, accounts: [], error: error.message };
+    }
+  }
+
+  // ==================== TRADING (GatewayAPI) ====================
+
+  async getPositions(accountId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Position/searchOpen',
+        'POST',
+        { accountId: parseInt(accountId) }
+      );
+      if (response.statusCode === 200) {
+        const positions = response.data.positions || response.data || [];
+        return { success: true, positions: Array.isArray(positions) ? positions : [] };
+      }
+      return { success: true, positions: [] };
+    } catch (error) {
+      return { success: true, positions: [], error: error.message };
+    }
+  }
+
+  async getOrders(accountId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Order/searchOpen',
+        'POST',
+        { accountId: parseInt(accountId) }
+      );
+      if (response.statusCode === 200) {
+        const orders = response.data.orders || response.data || [];
+        return { success: true, orders: Array.isArray(orders) ? orders : [] };
+      }
+      return { success: true, orders: [] };
+    } catch (error) {
+      return { success: true, orders: [], error: error.message };
+    }
+  }
+
+  async placeOrder(orderData) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Order/place',
+        'POST',
+        orderData
+      );
+      if (response.statusCode === 200 && response.data.success) {
+        return { success: true, order: response.data };
+      }
+      return { success: false, error: response.data.errorMessage || 'Order failed' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async cancelOrder(orderId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Order/cancel',
+        'POST',
+        { orderId: parseInt(orderId) }
+      );
+      return { success: response.statusCode === 200 && response.data.success };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async closePosition(accountId, contractId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Position/closeContract',
+        'POST',
+        { accountId: parseInt(accountId), contractId }
+      );
+      return { success: response.statusCode === 200 && response.data.success };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // ==================== TRADES & STATS ====================
+
+  async getTradeHistory(accountId, days = 30) {
+    try {
+      const endDate = new Date();
+      const startDate = new Date();
+      startDate.setDate(startDate.getDate() - days);
+      
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Trade/search',
+        'POST',
+        { 
+          accountId: parseInt(accountId),
+          startTimestamp: startDate.toISOString(),
+          endTimestamp: endDate.toISOString()
+        }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        let trades = [];
+        if (Array.isArray(response.data)) {
+          trades = response.data;
+        } else if (response.data.trades) {
+          trades = response.data.trades;
+        }
+        
+        return { 
+          success: true, 
+          trades: trades.map(t => ({
+            ...t,
+            timestamp: t.creationTimestamp || t.timestamp,
+            pnl: t.profitAndLoss || t.pnl || 0
+          }))
+        };
+      }
+      return { success: true, trades: [] };
+    } catch (error) {
+      return { success: true, trades: [], error: error.message };
+    }
+  }
+
+  async getDailyStats(accountId) {
+    try {
+      const now = new Date();
+      const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+      
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Trade/search',
+        'POST',
+        { 
+          accountId: parseInt(accountId),
+          startTimestamp: startOfMonth.toISOString(),
+          endTimestamp: now.toISOString()
+        }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        let trades = Array.isArray(response.data) ? response.data : (response.data.trades || []);
+        
+        // Group by day
+        const dailyPnL = {};
+        trades.forEach(t => {
+          const ts = t.creationTimestamp || t.timestamp;
+          if (ts) {
+            const d = new Date(ts);
+            const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+            dailyPnL[key] = (dailyPnL[key] || 0) + (t.profitAndLoss || t.pnl || 0);
+          }
+        });
+        
+        return { 
+          success: true, 
+          stats: Object.entries(dailyPnL).map(([date, pnl]) => ({ date, profitAndLoss: pnl }))
+        };
+      }
+      return { success: false, stats: [] };
+    } catch (error) {
+      return { success: false, stats: [], error: error.message };
+    }
+  }
+
+  async getLifetimeStats(accountId) {
+    try {
+      const tradesResult = await this.getTradeHistory(accountId, 90);
+      
+      if (!tradesResult.success || tradesResult.trades.length === 0) {
+        return { success: true, stats: null };
+      }
+
+      const trades = tradesResult.trades;
+      let stats = {
+        totalTrades: trades.length,
+        winningTrades: 0,
+        losingTrades: 0,
+        totalWinAmount: 0,
+        totalLossAmount: 0,
+        bestTrade: 0,
+        worstTrade: 0,
+        totalVolume: 0,
+        maxConsecutiveWins: 0,
+        maxConsecutiveLosses: 0,
+        longTrades: 0,
+        shortTrades: 0
+      };
+
+      let consecutiveWins = 0, consecutiveLosses = 0;
+
+      trades.forEach(t => {
+        const pnl = t.profitAndLoss || t.pnl || 0;
+        const size = t.size || t.quantity || 1;
+        
+        stats.totalVolume += Math.abs(size);
+        if (t.side === 0) stats.longTrades++;
+        else if (t.side === 1) stats.shortTrades++;
+        
+        if (pnl > 0) {
+          stats.winningTrades++;
+          stats.totalWinAmount += pnl;
+          if (pnl > stats.bestTrade) stats.bestTrade = pnl;
+          consecutiveWins++;
+          consecutiveLosses = 0;
+          if (consecutiveWins > stats.maxConsecutiveWins) stats.maxConsecutiveWins = consecutiveWins;
+        } else if (pnl < 0) {
+          stats.losingTrades++;
+          stats.totalLossAmount += Math.abs(pnl);
+          if (pnl < stats.worstTrade) stats.worstTrade = pnl;
+          consecutiveLosses++;
+          consecutiveWins = 0;
+          if (consecutiveLosses > stats.maxConsecutiveLosses) stats.maxConsecutiveLosses = consecutiveLosses;
+        }
+      });
+
+      stats.profitFactor = stats.totalLossAmount > 0 ? stats.totalWinAmount / stats.totalLossAmount : 0;
+      stats.avgWin = stats.winningTrades > 0 ? stats.totalWinAmount / stats.winningTrades : 0;
+      stats.avgLoss = stats.losingTrades > 0 ? stats.totalLossAmount / stats.losingTrades : 0;
+
+      return { success: true, stats };
+    } catch (error) {
+      return { success: false, stats: null, error: error.message };
+    }
+  }
+
+  // ==================== CONTRACTS ====================
+
+  async searchContracts(searchText) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Contract/search',
+        'POST',
+        { searchText, live: false }
+      );
+      if (response.statusCode === 200) {
+        return { success: true, contracts: response.data.contracts || response.data || [] };
+      }
+      return { success: false, contracts: [] };
+    } catch (error) {
+      return { success: false, contracts: [], error: error.message };
+    }
+  }
+}
+
+module.exports = { ProjectXService };

package/src/services/session.js

@@ -0,0 +1,143 @@
+/**
+ * Session Management
+ * Handles multi-connection state and persistence
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ProjectXService } = require('./projectx');
+
+const SESSION_FILE = path.join(os.homedir(), '.hedgequantx', 'session.json');
+
+// Session Storage
+const storage = {
+  save(sessions) {
+    try {
+      const dir = path.dirname(SESSION_FILE);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(SESSION_FILE, JSON.stringify(sessions, null, 2));
+    } catch (e) { /* ignore */ }
+  },
+  
+  load() {
+    try {
+      if (fs.existsSync(SESSION_FILE)) {
+        return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+      }
+    } catch (e) { /* ignore */ }
+    return [];
+  },
+  
+  clear() {
+    try {
+      if (fs.existsSync(SESSION_FILE)) {
+        fs.unlinkSync(SESSION_FILE);
+      }
+    } catch (e) { /* ignore */ }
+  }
+};
+
+// Connection Manager
+const connections = {
+  services: [],
+  
+  add(type, service, propfirm = null, token = null) {
+    this.services.push({ 
+      type, 
+      service, 
+      propfirm, 
+      token, 
+      connectedAt: new Date() 
+    });
+    this.saveToStorage();
+  },
+  
+  saveToStorage() {
+    const sessions = this.services.map(conn => ({
+      type: conn.type,
+      propfirm: conn.propfirm,
+      token: conn.service.token || conn.token
+    }));
+    storage.save(sessions);
+  },
+  
+  async restoreFromStorage() {
+    const sessions = storage.load();
+    for (const session of sessions) {
+      try {
+        if (session.type === 'projectx' && session.token) {
+          const service = new ProjectXService(session.propfirm.toLowerCase().replace(/ /g, '_'));
+          service.token = session.token;
+          
+          const userResult = await service.getUser();
+          if (userResult.success) {
+            this.services.push({
+              type: session.type,
+              service,
+              propfirm: session.propfirm,
+              token: session.token,
+              connectedAt: new Date()
+            });
+          }
+        }
+      } catch (e) { /* invalid session */ }
+    }
+    return this.services.length > 0;
+  },
+  
+  remove(index) {
+    this.services.splice(index, 1);
+    this.saveToStorage();
+  },
+  
+  getAll() {
+    return this.services;
+  },
+  
+  getByType(type) {
+    return this.services.filter(c => c.type === type);
+  },
+  
+  count() {
+    return this.services.length;
+  },
+  
+  async getAllAccounts() {
+    const allAccounts = [];
+    for (const conn of this.services) {
+      try {
+        const result = await conn.service.getTradingAccounts();
+        if (result.success && result.accounts) {
+          result.accounts.forEach(account => {
+            allAccounts.push({
+              ...account,
+              connectionType: conn.type,
+              propfirm: conn.propfirm || conn.type,
+              service: conn.service
+            });
+          });
+        }
+      } catch (e) { /* ignore */ }
+    }
+    return allAccounts;
+  },
+  
+  isConnected() {
+    return this.services.length > 0;
+  },
+  
+  disconnectAll() {
+    this.services.forEach(conn => {
+      if (conn.service && conn.service.logout) {
+        conn.service.logout();
+      }
+    });
+    this.services = [];
+    storage.clear();
+  }
+};
+
+module.exports = { storage, connections };

package/src/ui/box.js

@@ -0,0 +1,105 @@
+/**
+ * ASCII Box Drawing Utilities
+ */
+
+const chalk = require('chalk');
+const figlet = require('figlet');
+
+// Cache logo width
+let logoWidth = null;
+
+/**
+ * Get logo width for consistent box sizing
+ */
+const getLogoWidth = () => {
+  if (!logoWidth) {
+    const logoText = figlet.textSync('HEDGEQUANTX', { font: 'ANSI Shadow' });
+    const lines = logoText.split('\n').filter(line => line.trim().length > 0);
+    logoWidth = Math.max(...lines.map(line => line.length)) + 4;
+  }
+  return logoWidth;
+};
+
+/**
+ * Get visible length of text (excluding ANSI codes)
+ */
+const visibleLength = (text) => {
+  return (text || '').replace(/\x1b\[[0-9;]*m/g, '').length;
+};
+
+/**
+ * Center text in a given width
+ */
+const centerText = (text, width) => {
+  const len = visibleLength(text);
+  if (len >= width) return text;
+  const padding = width - len;
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  return ' '.repeat(leftPad) + text + ' '.repeat(rightPad);
+};
+
+/**
+ * Pad text to exact width
+ */
+const padText = (text, width) => {
+  const len = visibleLength(text);
+  if (len >= width) return text;
+  return (text || '') + ' '.repeat(width - len);
+};
+
+/**
+ * Draw box header with title
+ */
+const drawBoxHeader = (title, width) => {
+  const innerWidth = width - 2;
+  console.log(chalk.cyan('\u2554' + '\u2550'.repeat(innerWidth) + '\u2557'));
+  console.log(chalk.cyan('\u2551') + chalk.cyan.bold(centerText(title, innerWidth)) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2560' + '\u2550'.repeat(innerWidth) + '\u2563'));
+};
+
+/**
+ * Draw box footer
+ */
+const drawBoxFooter = (width) => {
+  const innerWidth = width - 2;
+  console.log(chalk.cyan('\u255A' + '\u2550'.repeat(innerWidth) + '\u255D'));
+};
+
+/**
+ * Draw a single row inside a box
+ */
+const drawBoxRow = (content, width) => {
+  const innerWidth = width - 2;
+  console.log(chalk.cyan('\u2551') + padText(content, innerWidth) + chalk.cyan('\u2551'));
+};
+
+/**
+ * Draw separator line inside a box
+ */
+const drawBoxSeparator = (width) => {
+  const innerWidth = width - 2;
+  console.log(chalk.cyan('\u2560' + '\u2500'.repeat(innerWidth) + '\u2563'));
+};
+
+/**
+ * Print centered logo
+ */
+const printLogo = () => {
+  const logoText = figlet.textSync('HEDGEQUANTX', { font: 'ANSI Shadow' });
+  console.log(chalk.cyan(logoText));
+  console.log(chalk.gray.italic('  Prop Futures Algo Trading CLI'));
+  console.log();
+};
+
+module.exports = {
+  getLogoWidth,
+  visibleLength,
+  centerText,
+  padText,
+  drawBoxHeader,
+  drawBoxFooter,
+  drawBoxRow,
+  drawBoxSeparator,
+  printLogo
+};

package/src/ui/device.js

@@ -0,0 +1,85 @@
+/**
+ * Device Detection & Terminal Info
+ */
+
+const chalk = require('chalk');
+
+let cachedDevice = null;
+
+/**
+ * Detect device type and terminal capabilities
+ */
+const detectDevice = () => {
+  const width = process.stdout.columns || 80;
+  const height = process.stdout.rows || 24;
+  const isTTY = process.stdout.isTTY || false;
+  const platform = process.platform;
+  const termProgram = process.env.TERM_PROGRAM || '';
+  const term = process.env.TERM || '';
+  const sshClient = process.env.SSH_CLIENT || process.env.SSH_TTY || '';
+  
+  // Detect mobile terminal apps
+  const mobileTerminals = ['termux', 'ish', 'a-shell', 'blink'];
+  const isMobileTerminal = mobileTerminals.some(t => 
+    termProgram.toLowerCase().includes(t) || 
+    term.toLowerCase().includes(t)
+  );
+  
+  // Device type based on width
+  let deviceType, deviceIcon;
+  
+  if (width < 50 || isMobileTerminal) {
+    deviceType = 'mobile';
+    deviceIcon = '[M]';
+  } else if (width < 80) {
+    deviceType = 'tablet';
+    deviceIcon = '[T]';
+  } else if (width < 120) {
+    deviceType = 'desktop';
+    deviceIcon = '[D]';
+  } else {
+    deviceType = 'desktop-large';
+    deviceIcon = '[L]';
+  }
+  
+  return {
+    width,
+    height,
+    deviceType,
+    deviceIcon,
+    isMobile: deviceType === 'mobile',
+    isTablet: deviceType === 'tablet',
+    isDesktop: deviceType === 'desktop' || deviceType === 'desktop-large',
+    isLargeDesktop: deviceType === 'desktop-large',
+    platform,
+    isTTY,
+    isRemote: !!sshClient,
+    termProgram,
+    supportsColor: chalk.supportsColor ? true : false,
+    maxContentWidth: Math.min(width - 4, deviceType === 'mobile' ? 45 : 70),
+    menuPageSize: deviceType === 'mobile' ? 6 : (deviceType === 'tablet' ? 10 : 15)
+  };
+};
+
+/**
+ * Get cached device info (updates on terminal resize)
+ */
+const getDevice = () => {
+  if (!cachedDevice) {
+    cachedDevice = detectDevice();
+    process.stdout.on('resize', () => {
+      cachedDevice = detectDevice();
+    });
+  }
+  return cachedDevice;
+};
+
+/**
+ * Get separator line based on device width
+ */
+const getSeparator = (char = '-') => {
+  const device = getDevice();
+  return char.repeat(Math.min(device.width - 2, 70));
+};
+
+module.exports = { detectDevice, getDevice, getSeparator };