@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/src/cli/logs.ts

@@ -6,12 +6,15 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as logger from '../utils/logger';
 import { loadConfig } from '../utils/config';
+import { safeJoin } from '../utils/path';
 import { 
   readJsonLog, 
   exportLogs, 
   stripAnsi,
   JsonLogEntry 
 } from '../utils/enhanced-logger';
+import { formatPotentialJsonMessage } from '../utils/log-formatter';
+import { startLogViewer } from '../ui/log-viewer';
 
 interface LogsOptions {
   runDir?: string;
@@ -21,6 +24,7 @@ interface LogsOptions {
   output?: string;
   tail?: number;
   follow: boolean;
+  interactive: boolean;
   filter?: string;
   level?: string;
   clean: boolean;
@@ -44,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)
@@ -66,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;
@@ -100,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,
@@ -114,15 +124,15 @@ function parseArgs(args: string[]): LogsOptions {
  * Find the latest run directory
  */
 function findLatestRunDir(logsDir: string): string | null {
-  const runsDir = path.join(logsDir, 'runs');
+  const runsDir = safeJoin(logsDir, 'runs');
   if (!fs.existsSync(runsDir)) return null;
   
   const runs = fs.readdirSync(runsDir)
     .filter(d => d.startsWith('run-'))
     .map(d => ({ 
       name: d, 
-      path: path.join(runsDir, d), 
-      mtime: fs.statSync(path.join(runsDir, d)).mtime.getTime() 
+      path: safeJoin(runsDir, d), 
+      mtime: fs.statSync(safeJoin(runsDir, d)).mtime.getTime() 
     }))
     .sort((a, b) => b.mtime - a.mtime);
   
@@ -133,11 +143,11 @@ function findLatestRunDir(logsDir: string): string | null {
  * List lanes in a run directory
  */
 function listLanes(runDir: string): string[] {
-  const lanesDir = path.join(runDir, 'lanes');
+  const lanesDir = safeJoin(runDir, 'lanes');
   if (!fs.existsSync(lanesDir)) return [];
   
   return fs.readdirSync(lanesDir)
-    .filter(d => fs.statSync(path.join(lanesDir, d)).isDirectory());
+    .filter(d => fs.statSync(safeJoin(lanesDir, d)).isDirectory());
 }
 
 /**
@@ -148,9 +158,9 @@ function displayTextLogs(
   options: LogsOptions
 ): void {
   let logFile: string;
-  const readableLog = path.join(laneDir, 'terminal-readable.log');
-  const rawLog = path.join(laneDir, 'terminal-raw.log');
-  const cleanLog = path.join(laneDir, 'terminal.log');
+  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+  const cleanLog = safeJoin(laneDir, 'terminal.log');
 
   if (options.raw) {
     logFile = rawLog;
@@ -171,10 +181,10 @@ function displayTextLogs(
   let content = fs.readFileSync(logFile, 'utf8');
   let lines = content.split('\n');
   
-  // Apply filter (escape to prevent regex injection)
+  // Apply filter (case-insensitive string match to avoid ReDoS)
   if (options.filter) {
-    const regex = new RegExp(escapeRegex(options.filter), 'i');
-    lines = lines.filter(line => regex.test(line));
+    const filterLower = options.filter.toLowerCase();
+    lines = lines.filter(line => line.toLowerCase().includes(filterLower));
   }
   
   // Apply tail
@@ -197,7 +207,7 @@ function displayJsonLogs(
   laneDir: string, 
   options: LogsOptions
 ): void {
-  const logFile = path.join(laneDir, 'terminal.jsonl');
+  const logFile = safeJoin(laneDir, 'terminal.jsonl');
   
   if (!fs.existsSync(logFile)) {
     console.log('No JSON log file found.');
@@ -211,10 +221,13 @@ function displayJsonLogs(
     entries = entries.filter(e => e.level === options.level);
   }
   
-  // Apply regex filter (escape to prevent regex injection)
+  // Apply filter (case-insensitive string match to avoid ReDoS)
   if (options.filter) {
-    const regex = new RegExp(escapeRegex(options.filter), 'i');
-    entries = entries.filter(e => regex.test(e.message) || regex.test(e.task || ''));
+    const filterLower = options.filter.toLowerCase();
+    entries = entries.filter(e => 
+      (e.message || '').toLowerCase().includes(filterLower) || 
+      (e.task && e.task.toLowerCase().includes(filterLower))
+    );
   }
   
   // Apply tail
@@ -227,9 +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();
-      console.log(`${levelColor}[${ts}] [${entry.level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${entry.message}`);
+      const formattedMsg = formatPotentialJsonMessage(message);
+      console.log(`${levelColor}[${ts}] [${level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${formattedMsg}`);
     }
   }
 }
@@ -290,8 +306,8 @@ function readAllLaneLogs(runDir: string): MergedLogEntry[] {
   const allEntries: MergedLogEntry[] = [];
   
   lanes.forEach((laneName, index) => {
-    const laneDir = path.join(runDir, 'lanes', laneName);
-    const jsonLogPath = path.join(laneDir, 'terminal.jsonl');
+    const laneDir = safeJoin(runDir, 'lanes', laneName);
+    const jsonLogPath = safeJoin(laneDir, 'terminal.jsonl');
     
     if (fs.existsSync(jsonLogPath)) {
       const entries = readJsonLog(jsonLogPath);
@@ -333,13 +349,13 @@ function displayMergedLogs(runDir: string, options: LogsOptions): void {
     entries = entries.filter(e => e.level === options.level);
   }
   
-  // Apply regex filter (escape to prevent regex injection)
+  // Apply filter (case-insensitive string match to avoid ReDoS)
   if (options.filter) {
-    const regex = new RegExp(escapeRegex(options.filter), 'i');
+    const filterLower = options.filter.toLowerCase();
     entries = entries.filter(e => 
-      regex.test(e.message) || 
-      regex.test(e.task || '') ||
-      regex.test(e.laneName)
+      (e.message || '').toLowerCase().includes(filterLower) || 
+      (e.task && e.task.toLowerCase().includes(filterLower)) ||
+      e.laneName.toLowerCase().includes(filterLower)
     );
   }
   
@@ -372,22 +388,26 @@ 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;
     }
     
-    console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${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}`);
   }
   
   console.log(`\n${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
@@ -426,17 +446,17 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
     const newEntries: MergedLogEntry[] = [];
     
     for (const lane of lanes) {
-      const laneDir = path.join(runDir, 'lanes', lane);
-      const jsonLogPath = path.join(laneDir, 'terminal.jsonl');
+      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());
@@ -458,6 +478,10 @@ function followAllLogs(runDir: string, options: LogsOptions): void {
         }
       } catch {
         // Ignore errors
+      } finally {
+        if (fd !== null) {
+          try { fs.closeSync(fd); } catch { /* ignore */ }
+        }
       }
     }
     
@@ -470,33 +494,39 @@ 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 regex filter (escape to prevent regex injection)
+      // Apply filter (case-insensitive string match to avoid ReDoS)
       if (options.filter) {
-        const regex = new RegExp(escapeRegex(options.filter), 'i');
-        if (!regex.test(entry.message) && !regex.test(entry.task || '') && !regex.test(entry.laneName)) {
+        const filterLower = options.filter.toLowerCase();
+        if (!message.toLowerCase().includes(filterLower) && 
+            !(entry.task && entry.task.toLowerCase().includes(filterLower)) && 
+            !entry.laneName.toLowerCase().includes(filterLower)) {
           continue;
         }
       }
       
       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;
       }
       
-      console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${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);
   
@@ -532,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`;
       }
   }
   
@@ -560,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;
@@ -615,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`;
   }
   
@@ -644,9 +684,9 @@ function escapeHtml(text: string): string {
  */
 function followLogs(laneDir: string, options: LogsOptions): void {
   let logFile: string;
-  const readableLog = path.join(laneDir, 'terminal-readable.log');
-  const rawLog = path.join(laneDir, 'terminal-raw.log');
-  const cleanLog = path.join(laneDir, 'terminal.log');
+  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+  const cleanLog = safeJoin(laneDir, 'terminal.log');
 
   if (options.raw) {
     logFile = rawLog;
@@ -675,23 +715,22 @@ 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();
         
-        // Apply filter (escape to prevent regex injection)
+        // Apply filter (case-insensitive string match to avoid ReDoS)
         if (options.filter) {
-          const regex = new RegExp(escapeRegex(options.filter), 'i');
+          const filterLower = options.filter.toLowerCase();
           const lines = content.split('\n');
-          content = lines.filter(line => regex.test(line)).join('\n');
+          content = lines.filter(line => line.toLowerCase().includes(filterLower)).join('\n');
         }
         
         // Clean ANSI if needed (unless raw mode)
@@ -705,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);
   
@@ -734,11 +777,11 @@ function displaySummary(runDir: string): void {
   }
   
   for (const lane of lanes) {
-    const laneDir = path.join(runDir, 'lanes', lane);
-    const cleanLog = path.join(laneDir, 'terminal.log');
-    const rawLog = path.join(laneDir, 'terminal-raw.log');
-    const jsonLog = path.join(laneDir, 'terminal.jsonl');
-    const readableLog = path.join(laneDir, 'terminal-readable.log');
+    const laneDir = safeJoin(runDir, 'lanes', lane);
+    const cleanLog = safeJoin(laneDir, 'terminal.log');
+    const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+    const jsonLog = safeJoin(laneDir, 'terminal.jsonl');
+    const readableLog = safeJoin(laneDir, 'terminal-readable.log');
     
     console.log(`  ${logger.COLORS.green}📁 ${lane}${logger.COLORS.reset}`);
     
@@ -794,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)
@@ -839,7 +886,7 @@ async function logs(args: string[]): Promise<void> {
   }
   
   // Find lane directory
-  const laneDir = path.join(runDir, 'lanes', options.lane);
+  const laneDir = safeJoin(runDir, 'lanes', options.lane);
   if (!fs.existsSync(laneDir)) {
     const lanes = listLanes(runDir);
     throw new Error(`Lane not found: ${options.lane}\nAvailable lanes: ${lanes.join(', ')}`);