@litmers/cursorflow-orchestrator 0.1.20 → 0.1.28

package/src/cli/logs.ts

@@ -14,6 +14,7 @@ import {
   JsonLogEntry 
 } from '../utils/enhanced-logger';
 import { formatPotentialJsonMessage } from '../utils/log-formatter';
+import { startLogViewer } from '../ui/log-viewer';
 
 interface LogsOptions {
   runDir?: string;
@@ -23,6 +24,7 @@ interface LogsOptions {
   output?: string;
   tail?: number;
   follow: boolean;
+  interactive: boolean;
   filter?: string;
   level?: string;
   clean: boolean;
@@ -46,12 +48,14 @@ View and export lane logs.
 
 Options:
   [run-dir]              Run directory (default: latest)
+  --run <id>             Specific run directory
   --lane <name>          Filter to specific lane
   --all, -a              View all lanes merged (sorted by timestamp)
   --format <fmt>         Output format: text, json, markdown, html (default: text)
   --output <path>        Write output to file instead of stdout
   --tail <n>             Show last n lines/entries (default: all)
   --follow, -f           Follow log output in real-time
+  --interactive, -i      Open interactive log viewer
   --filter <pattern>     Filter entries by regex pattern
   --level <level>        Filter by log level: stdout, stderr, info, error, debug
   --readable, -r         Show readable log (parsed AI output) (default)
@@ -68,23 +72,26 @@ Examples:
   cursorflow logs --all --format json          # Export all lanes as JSON
   cursorflow logs --all --filter "error"       # Filter all lanes for errors
   cursorflow logs --format json --output out.json  # Export as JSON
+  cursorflow logs -i                              # Interactive log viewer
+  cursorflow logs -i --run <id>                   # Specific run in interactive mode
   `);
 }
 
 function parseArgs(args: string[]): LogsOptions {
   const laneIdx = args.indexOf('--lane');
+  const runIdx = args.indexOf('--run');
   const formatIdx = args.indexOf('--format');
   const outputIdx = args.indexOf('--output');
   const tailIdx = args.indexOf('--tail');
   const filterIdx = args.indexOf('--filter');
   const levelIdx = args.indexOf('--level');
   
-  // Find run directory (first non-option argument)
-  const runDir = args.find((arg, i) => {
+  // Find run directory (first non-option argument or --run value)
+  let runDir = runIdx >= 0 ? args[runIdx + 1] : args.find((arg, i) => {
     if (arg.startsWith('--') || arg.startsWith('-')) return false;
     // Skip values for options
     const prevArg = args[i - 1];
-    if (prevArg && ['--lane', '--format', '--output', '--tail', '--filter', '--level'].includes(prevArg)) {
+    if (prevArg && ['--lane', '--run', '--format', '--output', '--tail', '--filter', '--level'].includes(prevArg)) {
       return false;
     }
     return true;
@@ -102,6 +109,7 @@ function parseArgs(args: string[]): LogsOptions {
     output: outputIdx >= 0 ? args[outputIdx + 1] : undefined,
     tail: tailIdx >= 0 ? parseInt(args[tailIdx + 1] || '50') : undefined,
     follow: args.includes('--follow') || args.includes('-f'),
+    interactive: args.includes('--interactive') || args.includes('-i'),
     filter: filterIdx >= 0 ? args[filterIdx + 1] : undefined,
     level: levelIdx >= 0 ? args[levelIdx + 1] : undefined,
     raw,
@@ -217,7 +225,7 @@ function displayJsonLogs(
   if (options.filter) {
     const filterLower = options.filter.toLowerCase();
     entries = entries.filter(e => 
-      e.message.toLowerCase().includes(filterLower) || 
+      (e.message || '').toLowerCase().includes(filterLower) || 
       (e.task && e.task.toLowerCase().includes(filterLower))
     );
   }
@@ -232,10 +240,12 @@ function displayJsonLogs(
   } else {
     // Display as formatted text
     for (const entry of entries) {
-      const levelColor = getLevelColor(entry.level);
+      const level = entry.level || 'info';
+      const message = entry.message || '';
+      const levelColor = getLevelColor(level);
       const ts = new Date(entry.timestamp).toLocaleTimeString();
-      const formattedMsg = formatPotentialJsonMessage(entry.message);
-      console.log(`${levelColor}[${ts}] [${entry.level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${formattedMsg}`);
+      const formattedMsg = formatPotentialJsonMessage(message);
+      console.log(`${levelColor}[${ts}] [${level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${formattedMsg}`);
     }
   }
 }
@@ -343,7 +353,7 @@ function displayMergedLogs(runDir: string, options: LogsOptions): void {
   if (options.filter) {
     const filterLower = options.filter.toLowerCase();
     entries = entries.filter(e => 
-      e.message.toLowerCase().includes(filterLower) || 
+      (e.message || '').toLowerCase().includes(filterLower) || 
       (e.task && e.task.toLowerCase().includes(filterLower)) ||
       e.laneName.toLowerCase().includes(filterLower)
     );
@@ -378,22 +388,25 @@ function displayMergedLogs(runDir: string, options: LogsOptions): void {
   // Display entries
   for (const entry of entries) {
     const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
-    const levelColor = getLevelColor(entry.level);
+    const level = entry.level || 'info';
+    const levelColor = getLevelColor(level);
     const laneColor = entry.laneColor;
     const lanePad = entry.laneName.substring(0, 12).padEnd(12);
-    const levelPad = entry.level.toUpperCase().padEnd(6);
+    const levelPad = level.toUpperCase().padEnd(6);
+    
+    const message = entry.message || '';
     
     // Skip session entries for cleaner output unless they're important
-    if (entry.level === 'session' && entry.message === 'Session started') {
+    if (level === 'session' && message === 'Session started') {
       console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Started ──${logger.COLORS.reset}`);
       continue;
     }
-    if (entry.level === 'session' && entry.message === 'Session ended') {
+    if (level === 'session' && message === 'Session ended') {
       console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Ended ──${logger.COLORS.reset}`);
       continue;
     }
     
-    const formattedMsg = formatPotentialJsonMessage(entry.message);
+    const formattedMsg = formatPotentialJsonMessage(message);
     console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${formattedMsg}`);
   }
   
@@ -436,14 +449,14 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
       const laneDir = safeJoin(runDir, 'lanes', lane);
       const jsonLogPath = safeJoin(laneDir, 'terminal.jsonl');
       
+      let fd: number | null = null;
       try {
-        // Use statSync directly to avoid TOCTOU race condition
-        const stats = fs.statSync(jsonLogPath);
+        // Use fstat on open fd to avoid TOCTOU race condition
+        fd = fs.openSync(jsonLogPath, 'r');
+        const stats = fs.fstatSync(fd);
         if (stats.size > lastPositions[lane]!) {
-          const fd = fs.openSync(jsonLogPath, 'r');
           const buffer = Buffer.alloc(stats.size - lastPositions[lane]!);
           fs.readSync(fd, buffer, 0, buffer.length, lastPositions[lane]!);
-          fs.closeSync(fd);
           
           const content = buffer.toString();
           const lines = content.split('\n').filter(l => l.trim());
@@ -465,6 +478,10 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
         }
       } catch {
         // Ignore errors
+      } finally {
+        if (fd !== null) {
+          try { fs.closeSync(fd); } catch { /* ignore */ }
+        }
       }
     }
     
@@ -477,13 +494,16 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
     
     // Apply filters and display
     for (let entry of newEntries) {
+      const level = entry.level || 'info';
+      const message = entry.message || '';
+      
       // Apply level filter
-      if (options.level && entry.level !== options.level) continue;
+      if (options.level && level !== options.level) continue;
       
       // Apply filter (case-insensitive string match to avoid ReDoS)
       if (options.filter) {
         const filterLower = options.filter.toLowerCase();
-        if (!entry.message.toLowerCase().includes(filterLower) && 
+        if (!message.toLowerCase().includes(filterLower) && 
             !(entry.task && entry.task.toLowerCase().includes(filterLower)) && 
             !entry.laneName.toLowerCase().includes(filterLower)) {
           continue;
@@ -491,21 +511,21 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
       }
       
       const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
-      const levelColor = getLevelColor(entry.level);
+      const levelColor = getLevelColor(level);
       const lanePad = entry.laneName.substring(0, 12).padEnd(12);
-      const levelPad = entry.level.toUpperCase().padEnd(6);
+      const levelPad = level.toUpperCase().padEnd(6);
       
       // Skip verbose session entries
-      if (entry.level === 'session') {
-        if (entry.message === 'Session started') {
+      if (level === 'session') {
+        if (message === 'Session started') {
           console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Started ──${logger.COLORS.reset}`);
-        } else if (entry.message === 'Session ended') {
+        } else if (message === 'Session ended') {
           console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Ended ──${logger.COLORS.reset}`);
         }
         continue;
       }
       
-      const formattedMsg = formatPotentialJsonMessage(entry.message);
+      const formattedMsg = formatPotentialJsonMessage(message);
       console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${formattedMsg}`);
     }
   }, 100);
@@ -542,7 +562,9 @@ function exportMergedLogs(runDir: string, format: string, outputPath?: string):
       // Text format
       for (const entry of entries) {
         const ts = new Date(entry.timestamp).toISOString();
-        output += `[${ts}] [${entry.laneName}] [${entry.level.toUpperCase()}] ${entry.message}\n`;
+        const level = entry.level || 'info';
+        const message = entry.message || '';
+        output += `[${ts}] [${entry.laneName}] [${level.toUpperCase()}] ${message}\n`;
       }
   }
   
@@ -570,8 +592,14 @@ function exportMergedToMarkdown(entries: MergedLogEntry[], runDir: string): stri
   
   for (const entry of entries) {
     const ts = new Date(entry.timestamp).toLocaleTimeString();
-    const message = entry.message.replace(/\|/g, '\\|').substring(0, 80);
-    md += `| ${ts} | ${entry.laneName} | ${entry.level} | ${message} |\n`;
+    const level = entry.level || 'info';
+    // Escape markdown table special characters: pipe, backslash, and newlines
+    const message = (entry.message || '')
+      .replace(/\\/g, '\\\\')
+      .replace(/\|/g, '\\|')
+      .replace(/\n/g, ' ')
+      .substring(0, 80);
+    md += `| ${ts} | ${entry.laneName} | ${level} | ${message} |\n`;
   }
   
   return md;
@@ -625,12 +653,14 @@ function exportMergedToHtml(entries: MergedLogEntry[], runDir: string): string {
     const ts = new Date(entry.timestamp).toLocaleTimeString();
     const laneIndex = lanes.indexOf(entry.laneName);
     const color = colors[laneIndex % colors.length];
+    const level = entry.level || 'info';
+    const message = entry.message || '';
     
-    html += `  <div class="entry ${entry.level}">
+    html += `  <div class="entry ${level}">
     <span class="time">${ts}</span>
     <span class="lane" style="color: ${color}">${entry.laneName}</span>
-    <span class="level">[${entry.level.toUpperCase()}]</span>
-    <span class="message">${escapeHtml(entry.message)}</span>
+    <span class="level">[${level.toUpperCase()}]</span>
+    <span class="message">${escapeHtml(message)}</span>
   </div>\n`;
   }
   
@@ -685,15 +715,14 @@ function followLogs(laneDir: string, options: LogsOptions): void {
   console.log(`${logger.COLORS.cyan}Following ${logFile}... (Ctrl+C to stop)${logger.COLORS.reset}\n`);
   
   const checkInterval = setInterval(() => {
+    // Use fstat on open fd to avoid TOCTOU race condition
+    let fd: number | null = null;
     try {
-      if (!fs.existsSync(logFile)) return;
-      
-      const stats = fs.statSync(logFile);
+      fd = fs.openSync(logFile, 'r');
+      const stats = fs.fstatSync(fd);
       if (stats.size > lastSize) {
-        const fd = fs.openSync(logFile, 'r');
         const buffer = Buffer.alloc(stats.size - lastSize);
         fs.readSync(fd, buffer, 0, buffer.length, lastSize);
-        fs.closeSync(fd);
         
         let content = buffer.toString();
         
@@ -715,8 +744,12 @@ function followLogs(laneDir: string, options: LogsOptions): void {
         
         lastSize = stats.size;
       }
-    } catch (e) {
+    } catch {
       // Ignore errors (file might be rotating)
+    } finally {
+      if (fd !== null) {
+        try { fs.closeSync(fd); } catch { /* ignore */ }
+      }
     }
   }, 100);
   
@@ -804,13 +837,17 @@ async function logs(args: string[]): Promise<void> {
   let runDir = options.runDir;
   if (!runDir || runDir === 'latest') {
     runDir = findLatestRunDir(config.logsDir) || undefined;
-    if (!runDir) {
-      throw new Error('No run directories found');
-    }
   }
   
-  if (!fs.existsSync(runDir)) {
-    throw new Error(`Run directory not found: ${runDir}`);
+  if (!runDir || !fs.existsSync(runDir)) {
+    console.error('No run found');
+    process.exit(1);
+  }
+  
+  // Handle interactive mode
+  if (options.interactive) {
+    await startLogViewer(runDir);
+    return;
   }
   
   // Handle --all option (view all lanes merged)