hedgequantx 2.9.59 → 2.9.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.59",
+  "version": "2.9.61",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/services/rithmic/contracts.js

@@ -216,9 +216,9 @@ const decodeProductCodes = (buffer) => {
       } else if (wireType === 2) {
         const [val, newOff] = readString(data, offset);
         offset = newOff;
-        // Field IDs from response_product_codes.proto
+        // Field IDs from Rithmic API
         if (fieldNumber === 110101) result.exchange = val;      // exchange
-        if (fieldNumber === 110102) result.productCode = val;   // product_code (ES, MES, MNQ, etc.)
+        if (fieldNumber === 100749) result.productCode = val;   // product_code (ES, MES, MNQ, etc.)
         if (fieldNumber === 110103) result.productName = val;   // product_name
       } else {
         break;

package/src/services/rithmic/protobuf-decoders.js

@@ -30,8 +30,9 @@ const PNL_FIELDS = {
 const SYMBOL_FIELDS = {
   TEMPLATE_ID: 154467,
   RP_CODE: 132766,
+  RP_CODE_2: 132764,      // Another rp_code field
   EXCHANGE: 110101,
-  PRODUCT_CODE: 110102,   // Base symbol (ES, NQ, MNQ)
+  PRODUCT_CODE: 100749,   // Base symbol (ES, NQ, MNQ) - actual field ID from Rithmic
   PRODUCT_NAME: 110103,   // Product name
   SYMBOL: 110100,         // Full contract symbol (ESH26)
   TRADING_SYMBOL: 157095, // Trading symbol
@@ -262,43 +263,45 @@ function decodeInstrumentPnL(buffer) {
 
 /**
  * Decode ResponseProductCodes (template 112) - list of available symbols
- * @param {Buffer} buffer - Raw protobuf buffer
+ * @param {Buffer} buffer - Raw protobuf buffer (with 4-byte length prefix)
  * @returns {Object} Decoded product codes
  */
 function decodeProductCodes(buffer) {
+  // Skip 4-byte length prefix
+  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
   const result = { rpCode: [] };
   let offset = 0;
 
-  while (offset < buffer.length) {
+  while (offset < data.length) {
     try {
-      const [tag, tagOffset] = readVarint(buffer, offset);
+      const [tag, tagOffset] = readVarint(data, offset);
       const wireType = tag & 0x7;
       const fieldNumber = tag >>> 3;
       offset = tagOffset;
 
       switch (fieldNumber) {
         case SYMBOL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(buffer, offset);
+          [result.templateId, offset] = readVarint(data, offset);
           break;
         case SYMBOL_FIELDS.RP_CODE:
           let rpCode;
-          [rpCode, offset] = readLengthDelimited(buffer, offset);
+          [rpCode, offset] = readLengthDelimited(data, offset);
           result.rpCode.push(rpCode);
           break;
         case SYMBOL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(buffer, offset);
+          [result.exchange, offset] = readLengthDelimited(data, offset);
           break;
         case SYMBOL_FIELDS.PRODUCT_CODE:
-          [result.productCode, offset] = readLengthDelimited(buffer, offset);
+          [result.productCode, offset] = readLengthDelimited(data, offset);
           break;
         case SYMBOL_FIELDS.PRODUCT_NAME:
-          [result.productName, offset] = readLengthDelimited(buffer, offset);
+          [result.productName, offset] = readLengthDelimited(data, offset);
           break;
         case SYMBOL_FIELDS.USER_MSG:
-          [result.userMsg, offset] = readLengthDelimited(buffer, offset);
+          [result.userMsg, offset] = readLengthDelimited(data, offset);
           break;
         default:
-          offset = skipField(buffer, offset, wireType);
+          offset = skipField(data, offset, wireType);
       }
     } catch (error) {
       break;

package/src/services/session.js

@@ -112,27 +112,36 @@ const connections = {
   },
 
   saveToStorage() {
-    const sessions = this.services.map(conn => ({
+    // Load existing sessions to preserve AI agents
+    const existingSessions = storage.load();
+    const aiSessions = existingSessions.filter(s => s.type === 'ai');
+    
+    // Build Rithmic sessions
+    const rithmicSessions = this.services.map(conn => ({
       type: conn.type,
       propfirm: conn.propfirm,
       propfirmKey: conn.service.propfirmKey || conn.propfirmKey,
       credentials: conn.service.credentials,
     }));
     
-    storage.save(sessions);
+    // Merge: AI sessions + Rithmic sessions
+    storage.save([...aiSessions, ...rithmicSessions]);
   },
 
   async restoreFromStorage() {
     loadServices();
     const sessions = storage.load();
     
-    if (!sessions.length) {
+    // Filter only Rithmic sessions (AI sessions are managed by ai-agents.js)
+    const rithmicSessions = sessions.filter(s => s.type === 'rithmic');
+    
+    if (!rithmicSessions.length) {
       return false;
     }
     
-    log.info('Restoring sessions', { count: sessions.length });
+    log.info('Restoring sessions', { count: rithmicSessions.length });
     
-    for (const session of sessions) {
+    for (const session of rithmicSessions) {
       try {
         await this._restoreSession(session);
       } catch (err) {

package/src/utils/prompts.js

@@ -1,19 +1,15 @@
 /**
- * @fileoverview Centralized prompts utility with animated yellow spinner
+ * @fileoverview Centralized prompts utility
  * @module utils/prompts
  * 
- * Custom readline-based prompts with animated spinner that runs
- * while waiting for user input. Uses inquirer only for complex
- * prompts (password, list selection).
+ * Simple prompts using inquirer for user input.
+ * No spinners on prompts - spinners are only for data loading (use ora).
  */
 
 const inquirer = require('inquirer');
 const readline = require('readline');
 const chalk = require('chalk');
 
-// Spinner frames for yellow waiting indicator
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-
 /** @type {readline.Interface|null} */
 let rl = null;
 
@@ -48,305 +44,45 @@ const closeReadline = () => {
 };
 
 /**
- * Animated spinner prompt using raw readline
- * Spinner animates while waiting for user input
- * @param {string} message - Prompt message
- * @returns {Promise<string>}
- */
-const animatedPrompt = (message) => {
-  return new Promise((resolve) => {
-    prepareStdin();
-    closeReadline();
-
-    let frameIndex = 0;
-    let userInput = '';
-    let cursorPos = 0;
-
-    // Enable raw mode for character-by-character input
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-
-    const render = () => {
-      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
-      const line = `\r${spinner} ${message} ${userInput}`;
-      process.stdout.write('\r\x1b[K'); // Clear line
-      process.stdout.write(line);
-    };
-
-    // Animate spinner every 80ms
-    const spinnerInterval = setInterval(() => {
-      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
-      render();
-    }, 80);
-
-    render();
-
-    const onData = (key) => {
-      const char = key.toString();
-      
-      // Enter key
-      if (char === '\r' || char === '\n') {
-        clearInterval(spinnerInterval);
-        process.stdin.removeListener('data', onData);
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
-        }
-        process.stdout.write('\n');
-        resolve(userInput);
-        return;
-      }
-      
-      // Ctrl+C
-      if (char === '\x03') {
-        clearInterval(spinnerInterval);
-        process.stdin.removeListener('data', onData);
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
-        }
-        process.stdout.write('\n');
-        process.exit(0);
-      }
-      
-      // Backspace
-      if (char === '\x7f' || char === '\b') {
-        if (userInput.length > 0) {
-          userInput = userInput.slice(0, -1);
-          render();
-        }
-        return;
-      }
-      
-      // Regular printable character
-      if (char >= ' ' && char <= '~') {
-        userInput += char;
-        render();
-      }
-    };
-
-    process.stdin.on('data', onData);
-  });
-};
-
-/**
- * Animated Y/N confirm prompt
- * Shows [Y/n] or [y/N] based on default
- * @param {string} message - Prompt message  
- * @param {boolean} defaultVal - Default value
- * @returns {Promise<boolean>}
- */
-const animatedConfirm = (message, defaultVal = true) => {
-  return new Promise((resolve) => {
-    prepareStdin();
-    closeReadline();
-
-    let frameIndex = 0;
-    const hint = defaultVal ? '[Y/n]' : '[y/N]';
-
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-
-    const render = () => {
-      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
-      process.stdout.write('\r\x1b[K');
-      process.stdout.write(`${spinner} ${message} ${chalk.dim(hint)} `);
-    };
-
-    const spinnerInterval = setInterval(() => {
-      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
-      render();
-    }, 80);
-
-    render();
-
-    const onData = (key) => {
-      const char = key.toString().toLowerCase();
-      
-      // Enter = use default
-      if (char === '\r' || char === '\n') {
-        cleanup();
-        process.stdout.write(defaultVal ? 'Yes' : 'No');
-        process.stdout.write('\n');
-        resolve(defaultVal);
-        return;
-      }
-      
-      // Y = yes
-      if (char === 'y') {
-        cleanup();
-        process.stdout.write('Yes');
-        process.stdout.write('\n');
-        resolve(true);
-        return;
-      }
-      
-      // N = no
-      if (char === 'n') {
-        cleanup();
-        process.stdout.write('No');
-        process.stdout.write('\n');
-        resolve(false);
-        return;
-      }
-      
-      // Ctrl+C
-      if (char === '\x03') {
-        cleanup();
-        process.stdout.write('\n');
-        process.exit(0);
-      }
-    };
-
-    const cleanup = () => {
-      clearInterval(spinnerInterval);
-      process.stdin.removeListener('data', onData);
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(false);
-      }
-    };
-
-    process.stdin.on('data', onData);
-  });
-};
-
-/**
- * Animated list selection with arrow keys
- * @param {string} message - Prompt message
- * @param {Array<{name: string, value: any}>} choices - Options
- * @returns {Promise<any>}
- */
-const animatedSelect = (message, choices) => {
-  return new Promise((resolve) => {
-    prepareStdin();
-    closeReadline();
-
-    let frameIndex = 0;
-    let selectedIndex = 0;
-    const validChoices = choices.filter(c => !c.disabled);
-
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-
-    const render = () => {
-      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
-      // Move cursor to start and clear down
-      process.stdout.write('\r\x1b[K');
-      process.stdout.write(`${spinner} ${message}\n`);
-      
-      validChoices.forEach((choice, i) => {
-        process.stdout.write('\x1b[K'); // Clear line
-        if (i === selectedIndex) {
-          process.stdout.write(`${chalk.cyan('❯')} ${chalk.cyan(choice.name)}\n`);
-        } else {
-          process.stdout.write(`  ${choice.name}\n`);
-        }
-      });
-      
-      // Move cursor back up
-      process.stdout.write(`\x1b[${validChoices.length + 1}A`);
-    };
-
-    const spinnerInterval = setInterval(() => {
-      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
-      render();
-    }, 80);
-
-    render();
-
-    let escapeSeq = '';
-    
-    const onData = (key) => {
-      const char = key.toString();
-      
-      // Handle escape sequences (arrow keys)
-      if (char === '\x1b') {
-        escapeSeq = char;
-        return;
-      }
-      
-      if (escapeSeq === '\x1b' && char === '[') {
-        escapeSeq += char;
-        return;
-      }
-      
-      if (escapeSeq === '\x1b[') {
-        escapeSeq = '';
-        // Up arrow
-        if (char === 'A') {
-          selectedIndex = Math.max(0, selectedIndex - 1);
-          render();
-          return;
-        }
-        // Down arrow
-        if (char === 'B') {
-          selectedIndex = Math.min(validChoices.length - 1, selectedIndex + 1);
-          render();
-          return;
-        }
-      }
-      
-      // Enter = select
-      if (char === '\r' || char === '\n') {
-        cleanup();
-        // Clear the menu lines
-        process.stdout.write('\r\x1b[K');
-        for (let i = 0; i < validChoices.length; i++) {
-          process.stdout.write('\x1b[B\x1b[K');
-        }
-        process.stdout.write(`\x1b[${validChoices.length}A`);
-        process.stdout.write(`${chalk.yellow('⠋')} ${message} ${chalk.cyan(validChoices[selectedIndex].name)}\n`);
-        resolve(validChoices[selectedIndex].value);
-        return;
-      }
-      
-      // Ctrl+C
-      if (char === '\x03') {
-        cleanup();
-        process.stdout.write('\n');
-        process.exit(0);
-      }
-    };
-
-    const cleanup = () => {
-      clearInterval(spinnerInterval);
-      process.stdin.removeListener('data', onData);
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(false);
-      }
-    };
-
-    process.stdin.on('data', onData);
-  });
-};
-
-/**
- * Wait for Enter key with animated spinner
- * @param {string} [message='Press Enter to continue...'] - Message to display
+ * Wait for Enter key
+ * @param {string} [message='Press Enter to continue...'] - Message
  * @returns {Promise<void>}
  */
 const waitForEnter = async (message = 'Press Enter to continue...') => {
-  await animatedPrompt(message);
+  closeReadline();
+  prepareStdin();
+  
+  await inquirer.prompt([{
+    type: 'input',
+    name: 'continue',
+    message,
+    prefix: '',
+  }]);
 };
 
 /**
- * Text input with animated spinner
+ * Text input
  * @param {string} message - Prompt message
  * @param {string} [defaultVal=''] - Default value
  * @returns {Promise<string>}
  */
 const textInput = async (message, defaultVal = '') => {
-  const displayMsg = defaultVal ? `${message} (${defaultVal})` : message;
-  const value = await animatedPrompt(displayMsg);
-  return value || defaultVal;
+  closeReadline();
+  prepareStdin();
+
+  const { value } = await inquirer.prompt([{
+    type: 'input',
+    name: 'value',
+    message,
+    default: defaultVal,
+    prefix: '',
+  }]);
+
+  return value;
 };
 
 /**
- * Password input (masked) - uses inquirer for masking
+ * Password input (masked)
  * @param {string} message - Prompt message
  * @returns {Promise<string>}
  */
@@ -357,7 +93,7 @@ const passwordInput = async (message) => {
   const { value } = await inquirer.prompt([{
     type: 'password',
     name: 'value',
-    message: `${chalk.yellow('⠋')} ${message}`,
+    message,
     mask: '*',
     prefix: '',
   }]);
@@ -366,17 +102,33 @@ const passwordInput = async (message) => {
 };
 
 /**
- * Confirm prompt with animated spinner (Y/n)
+ * Confirm prompt with Yes/No selection
  * @param {string} message - Prompt message
  * @param {boolean} [defaultVal=true] - Default value
  * @returns {Promise<boolean>}
  */
 const confirmPrompt = async (message, defaultVal = true) => {
-  return animatedConfirm(message, defaultVal);
+  closeReadline();
+  prepareStdin();
+
+  const choices = defaultVal
+    ? [{ name: 'Yes', value: true }, { name: 'No', value: false }]
+    : [{ name: 'No', value: false }, { name: 'Yes', value: true }];
+
+  const { value } = await inquirer.prompt([{
+    type: 'list',
+    name: 'value',
+    message,
+    choices,
+    prefix: '',
+    loop: false,
+  }]);
+
+  return value;
 };
 
 /**
- * Number input with animated spinner and validation
+ * Number input with validation
  * @param {string} message - Prompt message
  * @param {number} [defaultVal=1] - Default value
  * @param {number} [min=1] - Minimum value
@@ -384,40 +136,55 @@ const confirmPrompt = async (message, defaultVal = true) => {
  * @returns {Promise<number>}
  */
 const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
-  const displayMsg = `${message} (${min}-${max}, default: ${defaultVal})`;
-  
-  while (true) {
-    const value = await animatedPrompt(displayMsg);
-    
-    if (!value) return defaultVal;
-    
-    const num = parseInt(value, 10);
-    if (isNaN(num)) {
-      console.log(chalk.red('Please enter a valid number'));
-      continue;
-    }
-    if (num < min || num > max) {
-      console.log(chalk.red(`Please enter a number between ${min} and ${max}`));
-      continue;
-    }
-    return num;
-  }
+  closeReadline();
+  prepareStdin();
+
+  const { value } = await inquirer.prompt([{
+    type: 'input',
+    name: 'value',
+    message: `${message} (${min}-${max})`,
+    default: String(defaultVal),
+    prefix: '',
+    validate: (v) => {
+      const n = parseInt(v, 10);
+      if (isNaN(n)) return 'Enter a number';
+      if (n < min) return `Min: ${min}`;
+      if (n > max) return `Max: ${max}`;
+      return true;
+    },
+  }]);
+
+  return parseInt(value, 10) || defaultVal;
 };
 
 /**
- * Select from options with animated spinner and arrow keys
+ * Select from options with arrow keys
  * @param {string} message - Prompt message
  * @param {Array<{label: string, value: any, disabled?: boolean}>} options - Options
  * @returns {Promise<any>}
  */
 const selectOption = async (message, options) => {
-  const choices = options.map(opt => ({
-    name: opt.label,
-    value: opt.value,
-    disabled: opt.disabled || false,
-  }));
+  closeReadline();
+  prepareStdin();
+
+  const choices = options.map(opt => {
+    if (opt.disabled) {
+      return new inquirer.Separator(opt.label);
+    }
+    return { name: opt.label, value: opt.value };
+  });
 
-  return animatedSelect(message, choices);
+  const { value } = await inquirer.prompt([{
+    type: 'list',
+    name: 'value',
+    message,
+    choices,
+    prefix: '',
+    loop: false,
+    pageSize: 15,
+  }]);
+
+  return value;
 };
 
 module.exports = {