vibex-sh 0.11.0 → 0.11.1

package/index.js

@@ -17,6 +17,7 @@ const MAX_POLL_ATTEMPTS = 60;
 const WEBSOCKET_CLOSE_TIMEOUT_MS = 2000;
 const DEFAULT_WORKER_URL = 'https://ingest.vibex.sh';
 const DEFAULT_WEB_URL = 'https://vibex.sh';
+const PIPED_INPUT_DELAY_MS = parseInt(process.env.VIBEX_PIPE_DELAY_MS || '300', 10);
 
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -389,24 +390,38 @@ async function handleInit(options) {
       ];
     }
     
-    // Filter out mandatory parsers for selection (if any)
-    const selectableParsers = availableParsers.filter(p => !p.isMandatory);
+    // Mandatory parsers that are always included
+    const mandatoryParserIds = ['json-in-text', 'raw', 'keyvalue', 'stacktrace', 'smart-pattern'];
     
-    console.log('  What kind of logs are these? (Optional - leave empty for auto-detection)');
+    // Filter out mandatory parsers for selection (only optional parsers can be selected)
+    const selectableParsers = availableParsers.filter(p => !mandatoryParserIds.includes(p.id) && !p.isMandatory);
+    
+    // Pre-select mandatory parsers
+    let enabledParsers = [...mandatoryParserIds];
+    
+    console.log('  Mandatory parsers are automatically included:');
+    mandatoryParserIds.forEach(id => {
+      const parser = availableParsers.find(p => p.id === id);
+      if (parser) {
+        console.log(`    ✓ ${parser.name}`);
+      }
+    });
+    console.log('');
+    
+    console.log('  Select additional optional parsers (leave empty for mandatory only):');
     if (selectableParsers.length > 0) {
-      console.log('  Available log types:');
+      console.log('  Available optional parsers:');
       selectableParsers.forEach((p, i) => {
         console.log(`    ${i + 1}. ${p.name} (${p.id})`);
       });
-      console.log('    (Leave empty for auto-detection)\n');
+      console.log('    (Leave empty for mandatory parsers only)\n');
     } else {
-      console.log('  Available log types: (Leave empty for auto-detection)\n');
+      console.log('  No additional optional parsers available.\n');
     }
     
-    const answer = await question('  Enter comma-separated numbers or parser IDs (e.g., 1,2 or nginx,apache): ');
+    const answer = await question('  Enter comma-separated numbers or parser IDs (e.g., 1,2 or docker,kubernetes): ');
     rl.close();
     
-    let enabledParsers = [];
     if (answer.trim()) {
       const selections = answer.split(',').map(s => s.trim());
       selections.forEach(sel => {
@@ -424,7 +439,9 @@ async function handleInit(options) {
     const parserFlag = options.parser || options.parsers;
     if (parserFlag) {
       if (typeof parserFlag === 'string') {
-        enabledParsers = parserFlag.split(',').map(p => p.trim());
+        // Add optional parsers from flag, but always include mandatory
+        const flagParsers = parserFlag.split(',').map(p => p.trim());
+        enabledParsers = [...new Set([...mandatoryParserIds, ...flagParsers])];
       }
     }
     
@@ -466,10 +483,18 @@ async function handleInit(options) {
     
       console.log('\n  ✅ Session created successfully!\n');
       printBanner(createdSessionId, createdAuthCode);
-    if (enabledParsers.length > 0) {
-      console.log(`  📋 Log Types: ${enabledParsers.join(', ')}`);
-    } else {
-      console.log('  📋 Log Types: Auto-detection (default parsers)');
+    
+    // Separate mandatory and optional parsers for display
+    const mandatoryIncluded = enabledParsers.filter(id => mandatoryParserIds.includes(id));
+    const optionalIncluded = enabledParsers.filter(id => !mandatoryParserIds.includes(id));
+    
+    if (mandatoryIncluded.length > 0) {
+      console.log(`  📋 Mandatory parsers: ${mandatoryIncluded.join(', ')}`);
+    }
+    if (optionalIncluded.length > 0) {
+      console.log(`  📋 Optional parsers: ${optionalIncluded.join(', ')}`);
+    } else if (mandatoryIncluded.length === mandatoryParserIds.length) {
+      console.log('  📋 Using mandatory parsers only');
     }
     console.log(`\n  💡 Use this session ID: ${createdSessionId}`);
     console.log(`  Example: echo '{"cpu": 45}' | npx vibex-sh -s ${createdSessionId}\n`);
@@ -1036,6 +1061,56 @@ async function handleSendLogs(options) {
     process.exit(0);
   }
 
+  // Rate limiting queue for piped input
+  const pipedLogQueue = [];
+  let isProcessingQueue = false;
+  let queueProcessingTimeout = null;
+
+  const processPipedLogQueue = async () => {
+    if (isProcessingQueue) {
+      return;
+    }
+
+    if (pipedLogQueue.length === 0) {
+      return;
+    }
+
+    isProcessingQueue = true;
+
+    try {
+      while (pipedLogQueue.length > 0) {
+        const logData = pipedLogQueue.shift();
+        await sendLogViaHTTP(logData);
+        
+        // Wait before sending the next log (only if there are more logs in queue)
+        if (pipedLogQueue.length > 0) {
+          await new Promise(resolve => setTimeout(resolve, PIPED_INPUT_DELAY_MS));
+        }
+      }
+    } finally {
+      isProcessingQueue = false;
+    }
+  };
+
+  const queuePipedLog = (logData) => {
+    pipedLogQueue.push(logData);
+    
+    // Start processing if not already processing
+    if (!isProcessingQueue) {
+      // Clear any existing timeout
+      if (queueProcessingTimeout) {
+        clearTimeout(queueProcessingTimeout);
+        queueProcessingTimeout = null;
+      }
+      // Process queue with a small initial delay to batch rapid inputs
+      queueProcessingTimeout = setTimeout(() => {
+        processPipedLogQueue().catch((error) => {
+          console.error('  ✗ Error processing log queue:', error.message);
+        });
+      }, 10);
+    }
+  };
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -1086,13 +1161,29 @@ async function handleSendLogs(options) {
       };
     }
 
-    // Send logs via HTTP POST immediately - don't wait for WebSocket
-    // WebSocket is only for receiving logs and auth codes, not required for sending
-    sendLogViaHTTP(logData);
+    // Queue logs for rate-limited sending when input is piped
+    // This prevents overwhelming rate limits when piping large files
+    queuePipedLog(logData);
   });
 
   rl.on('close', async () => {
-    // Wait for queued logs to be sent
+    // Clear any pending queue processing timeout
+    if (queueProcessingTimeout) {
+      clearTimeout(queueProcessingTimeout);
+      queueProcessingTimeout = null;
+    }
+    
+    // Process any remaining logs in the piped queue
+    // Keep processing until queue is empty and not currently processing
+    while (pipedLogQueue.length > 0 || isProcessingQueue) {
+      await processPipedLogQueue();
+      // Small delay to allow processing to complete
+      if (pipedLogQueue.length > 0 || isProcessingQueue) {
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+    }
+    
+    // Wait for queued logs to be sent (WebSocket queue)
     const waitForQueue = () => {
       return new Promise((resolve) => {
         if (logQueue.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibex-sh",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Zero-config observability CLI - pipe logs and visualize instantly",
   "type": "module",
   "bin": {