dashcam 1.0.1-beta.2 → 1.0.1-beta.21

package/bin/dashcam.js

@@ -26,7 +26,7 @@ if (!fs.existsSync(APP.recordingsDir)) {
 
 program
   .name('dashcam')
-  .description('CLI version of Dashcam screen recorder')
+  .description('Capture the steps to reproduce every bug.')
   .version(APP.version)
   .option('-v, --verbose', 'Enable verbose logging output')
   .hook('preAction', (thisCommand) => {
@@ -39,8 +39,8 @@ program
 
 program
   .command('auth')
-  .description('Authenticate with TestDriver using an API key')
-  .argument('<apiKey>', 'Your TestDriver API key')
+  .description("Authenticate the dashcam desktop using a team's apiKey")
+  .argument('<api-key>', 'Your team API key')
   .action(async (apiKey, options, command) => {
     try {
       logger.verbose('Starting authentication process', { 
@@ -75,121 +75,199 @@ program
     }
   });
 
+// Shared recording action to avoid duplication
+async function recordingAction(options, command) {
+  try {
+    const silent = options.silent;
+    const log = (...args) => { if (!silent) console.log(...args); };
+    const logError = (...args) => { if (!silent) console.error(...args); };
+    
+    // Check if recording is already active
+    if (processManager.isRecordingActive()) {
+      const status = processManager.getActiveStatus();
+      const duration = ((Date.now() - status.startTime) / 1000).toFixed(1);
+      log('Recording already in progress');
+      log(`Duration: ${duration} seconds`);
+      log(`PID: ${status.pid}`);
+      log('Use "dashcam stop" to stop the recording');
+      process.exit(0);
+    }
+
+    // Check authentication
+    if (!await auth.isAuthenticated()) {
+      log('You need to login first. Run: dashcam auth <api-key>');
+      process.exit(1);
+    }
+
+    // Check for piped input (description from stdin) if description option not set
+    let description = options.description;
+    if (!description && !process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      description = Buffer.concat(chunks).toString('utf-8');
+    }
+
+    // Check screen recording permissions (macOS only)
+    const { ensurePermissions } = await import('../lib/permissions.js');
+    const hasPermissions = await ensurePermissions();
+    if (!hasPermissions) {
+      log('\n⚠️  Cannot start recording without screen recording permission.');
+      process.exit(1);
+    }
+
+    // Start recording in background mode
+    log('Starting recording in background...');
+    
+    try {
+      const result = await processManager.startRecording({
+        fps: parseInt(options.fps) || 30,
+        audio: options.audio,
+        output: options.output,
+        title: options.title,
+        description: description,
+        project: options.project || options.k // Support both -p and -k for project
+      });
+
+      log(`✅ Recording started successfully (PID: ${result.pid})`);
+      log(`Output: ${result.outputPath}`);
+      log('');
+      log('Use "dashcam status" to check progress');
+      log('Use "dashcam stop" to stop recording and upload');
+      
+      process.exit(0);
+    } catch (error) {
+      logError('Failed to start recording:', error.message);
+      process.exit(1);
+    }
+  } catch (error) {
+    logger.error('Failed to start recording:', error);
+    if (!options.silent) console.error('Failed to start recording:', error.message);
+    process.exit(1);
+  }
+}
+
+// 'create' command - creates a clip from current recording (like stop but with more options)
 program
-  .command('record')
-  .description('Start a background screen recording')
-  .option('-a, --audio', 'Include audio in the recording')
-  .option('-f, --fps <fps>', 'Frames per second (default: 30)', '30')
-  .option('-o, --output <path>', 'Custom output path')
-  .option('-t, --title <title>', 'Title for the recording')
-  .option('-d, --description <description>', 'Description for the recording (supports markdown)')
-  .option('-p, --project <project>', 'Project ID to upload the recording to')
-  .action(async (options, command) => {
+  .command('create')
+  .description('Create a clip and output the resulting url or markdown. Will launch desktop app for local editing before publishing.')
+  .option('-t, --title <string>', 'Title of the replay. Automatically generated if not supplied.')
+  .option('-d, --description [text]', 'Replay markdown body. This may also be piped in: `cat README.md | dashcam create`')
+  .option('--md', 'Returns code for a rich markdown image link.')
+  .option('-k, --project <project>', 'Project ID to publish to')
+  .action(async (options) => {
     try {
-      // Check if recording is already active
-      if (processManager.isRecordingActive()) {
-        const status = processManager.getActiveStatus();
-        const duration = ((Date.now() - status.startTime) / 1000).toFixed(1);
-        console.log('Recording already in progress');
-        console.log(`Duration: ${duration} seconds`);
-        console.log(`PID: ${status.pid}`);
-        console.log('Use "dashcam stop" to stop the recording');
-        process.exit(0);
+      // Check for piped input (description from stdin)
+      let description = options.description;
+      if (!description && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        description = Buffer.concat(chunks).toString('utf-8');
       }
 
-      // Check authentication
-      if (!await auth.isAuthenticated()) {
-        console.log('You need to login first. Run: dashcam auth <api-key>');
-        process.exit(1);
+      if (!processManager.isRecordingActive()) {
+        console.log('No active recording to create clip from');
+        console.log('Start a recording first with "dashcam record" or "dashcam start"');
+        process.exit(0);
       }
 
-      // Check screen recording permissions (macOS only)
-      const { ensurePermissions } = await import('../lib/permissions.js');
-      const hasPermissions = await ensurePermissions();
-      if (!hasPermissions) {
-        console.log('\n⚠️  Cannot start recording without screen recording permission.');
+      const activeStatus = processManager.getActiveStatus();
+      
+      console.log('Creating clip from recording...');
+      
+      const result = await processManager.stopActiveRecording();
+      
+      if (!result) {
+        console.log('Failed to stop recording');
         process.exit(1);
       }
 
-      // Always use background mode
-      console.log('Starting recording...');
+      console.log('Recording stopped successfully');
       
+      // Upload the recording
+      console.log('Uploading clip...');
       try {
-        const result = await processManager.startRecording({
-          fps: parseInt(options.fps) || 30,
-          audio: options.audio,
-          output: options.output,
-          title: options.title,
-          description: options.description,
-          project: options.project
+        const uploadResult = await upload(result.outputPath, {
+          title: options.title || activeStatus?.options?.title || 'Dashcam Recording',
+          description: description || activeStatus?.options?.description,
+          project: options.project || options.k || activeStatus?.options?.project,
+          duration: result.duration,
+          clientStartDate: result.clientStartDate,
+          apps: result.apps,
+          icons: result.icons,
+          gifPath: result.gifPath,
+          snapshotPath: result.snapshotPath
         });
-
-        console.log(`Recording started successfully (PID: ${result.pid})`);
-        console.log(`Output: ${result.outputPath}`);
-        console.log('Use "dashcam status" to check progress');
-        console.log('Use "dashcam stop" to stop recording and upload');
-        
-        // Keep this process alive for background recording
-        console.log('Recording is running in background...');
-        
-        // Set up signal handlers for graceful shutdown
-        let isShuttingDown = false;
-        const handleShutdown = async (signal) => {
-          if (isShuttingDown) {
-            console.log('Shutdown already in progress...');
-            return;
-          }
-          isShuttingDown = true;
-          
-          console.log(`\nReceived ${signal}, stopping background recording...`);
-          try {
-            // Stop the recording using the recorder directly (not processManager)
-            const { stopRecording } = await import('../lib/recorder.js');
-            const stopResult = await stopRecording();
-            
-            if (stopResult) {
-              console.log('Recording stopped:', stopResult.outputPath);
-              
-              // Import and call upload function with the correct format
-              const { upload } = await import('../lib/uploader.js');
-              
-              console.log('Starting upload...');
-              await upload(stopResult.outputPath, {
-                title: options.title || 'Dashcam Recording',
-                description: options.description || 'Recorded with Dashcam CLI',
-                project: options.project,
-                duration: stopResult.duration,
-                clientStartDate: stopResult.clientStartDate,
-                apps: stopResult.apps,
-                logs: stopResult.logs,
-                gifPath: stopResult.gifPath,
-                snapshotPath: stopResult.snapshotPath
-              });
-              
-              console.log('Upload completed successfully!');
-            }
-            
-            // Clean up process files
-            processManager.cleanup();
-          } catch (error) {
-            console.error('Error during shutdown:', error.message);
-            logger.error('Error during shutdown:', error);
-          }
-          process.exit(0);
-        };
-        
-        process.on('SIGINT', () => handleShutdown('SIGINT'));
-        process.on('SIGTERM', () => handleShutdown('SIGTERM'));
         
-        // Keep the process alive
-        await new Promise(() => {});
-      } catch (error) {
-        console.error('Failed to start recording:', error.message);
+        // Output based on format option
+        if (options.md) {
+          const replayId = uploadResult.replay?.id;
+          const shareKey = uploadResult.shareLink.split('share=')[1];
+          console.log(`[![Dashcam - ${options.title || 'New Replay'}](https://replayable-api-production.herokuapp.com/replay/${replayId}/gif?shareKey=${shareKey})](${uploadResult.shareLink})`);
+          console.log('');
+          console.log(`Watch [Dashcam - ${options.title || 'New Replay'}](${uploadResult.shareLink}) on Dashcam`);
+        } else {
+          console.log(uploadResult.shareLink);
+        }
+      } catch (uploadError) {
+        console.error('Upload failed:', uploadError.message);
+        console.log('Recording saved locally:', result.outputPath);
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      logger.error('Error creating clip:', error);
+      console.error('Failed to create clip:', error.message);
+      process.exit(1);
+    }
+  });
+
+// 'record' command - the main recording command with all options
+program
+  .command('record')
+  .description('Start a recording terminal to be included in your dashcam video recording')
+  .option('-a, --audio', 'Include audio in the recording')
+  .option('-f, --fps <fps>', 'Frames per second (default: 30)', '30')
+  .option('-o, --output <path>', 'Custom output path')
+  .option('-t, --title <title>', 'Title for the recording')
+  .option('-d, --description <description>', 'Description for the recording (supports markdown)')
+  .option('-p, --project <project>', 'Project ID to upload the recording to')
+  .option('-s, --silent', 'Silent mode - suppress all output')
+  .action(recordingAction);
+
+program
+  .command('pipe')
+  .description('Pipe command output to dashcam to be included in recorded video')
+  .action(async () => {
+    try {
+      // Check if recording is active
+      if (!processManager.isRecordingActive()) {
+        console.error('No active recording. Start a recording first with "dashcam record" or "dashcam start"');
         process.exit(1);
       }
+
+      // Read from stdin
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+        // Also output to stdout so pipe continues to work
+        process.stdout.write(chunk);
+      }
+      const content = Buffer.concat(chunks).toString('utf-8');
+
+      // Import the log tracker to add the piped content
+      const { logsTrackerManager } = await import('../lib/logs/index.js');
+      
+      // Add piped content as a log entry
+      logsTrackerManager.addPipedLog(content);
+      
+      process.exit(0);
     } catch (error) {
-      logger.error('Failed to start recording:', error);
-      console.error('Failed to start recording:', error.message);
+      logger.error('Failed to pipe content:', error);
+      console.error('Failed to pipe content:', error.message);
       process.exit(1);
     }
   });
@@ -216,43 +294,94 @@ program
 
 
 
+// 'start' command - alias for record with simple instant replay mode
+program
+  .command('start')
+  .description('Start instant replay recording on dashcam')
+  .action(async () => {
+    // Call recordingAction with minimal options for instant replay
+    await recordingAction({ 
+      fps: '30', 
+      audio: false, 
+      silent: false 
+    }, null);
+  });
+
 program
   .command('track')
-  .description('Track logs from web URLs or application files')
-  .option('--web <pattern>', 'Web URL pattern to track (can use wildcards like *)')
-  .option('--app <pattern>', 'Application file pattern to track (can use wildcards like *)')
-  .option('--name <name>', 'Name for the tracking configuration')
+  .description('Add a logs config to Dashcam')
+  .option('--name <name>', 'Name for the tracking configuration (required)')
+  .option('--type <type>', 'Type of tracker: "application" or "web" (required)')
+  .option('--pattern <pattern>', 'Pattern to track (can be used multiple times)', (value, previous) => {
+    return previous ? previous.concat([value]) : [value];
+  })
+  .option('--web <pattern>', 'Web URL pattern to track (can use wildcards like *) - deprecated, use --type=web --pattern instead')
+  .option('--app <pattern>', 'Application file pattern to track (can use wildcards like *) - deprecated, use --type=application --pattern instead')
   .action(async (options) => {
     try {
-      // Validate that at least one pattern is provided
-      if (!options.web && !options.app) {
-        console.error('Error: Must provide either --web or --app pattern');
-        process.exit(1);
-      }
-
-      if (options.web) {
-        const config = {
-          name: options.name || 'Web Pattern',
-          type: 'web',
-          patterns: [options.web],
-          enabled: true
-        };
+      // Support both old and new syntax
+      // New syntax: --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"
+      // Old syntax: --web <pattern> --app <pattern>
+      
+      if (options.type && options.pattern) {
+        // New syntax validation
+        if (!options.name) {
+          console.error('Error: --name is required when using --type and --pattern');
+          console.log('Example: dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
+          process.exit(1);
+        }
+        
+        if (options.type !== 'web' && options.type !== 'application') {
+          console.error('Error: --type must be either "web" or "application"');
+          process.exit(1);
+        }
         
-        await createPattern(config);
-        console.log('Web tracking pattern added successfully:', options.web);
-      }
-
-      if (options.app) {
         const config = {
-          name: options.name || 'App Pattern',
-          type: 'application',
-          patterns: [options.app],
+          name: options.name,
+          type: options.type,
+          patterns: options.pattern,
           enabled: true
         };
         
         await createPattern(config);
-        console.log('Application tracking pattern added successfully:', options.app);
+        console.log(`${options.type === 'web' ? 'Web' : 'Application'} tracking pattern added successfully:`, options.name);
+        console.log('Patterns:', options.pattern.join(', '));
+        
+      } else if (options.web || options.app) {
+        // Old syntax for backward compatibility
+        if (options.web) {
+          const config = {
+            name: options.name || 'Web Pattern',
+            type: 'web',
+            patterns: [options.web],
+            enabled: true
+          };
+          
+          await createPattern(config);
+          console.log('Web tracking pattern added successfully:', options.web);
+        }
+
+        if (options.app) {
+          const config = {
+            name: options.name || 'App Pattern',
+            type: 'application',
+            patterns: [options.app],
+            enabled: true
+          };
+          
+          await createPattern(config);
+          console.log('Application tracking pattern added successfully:', options.app);
+        }
+      } else {
+        console.error('Error: Must provide either:');
+        console.log('  --name --type --pattern (new syntax)');
+        console.log('  --web or --app (old syntax)');
+        console.log('\nExamples:');
+        console.log('  dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
+        console.log('  dashcam track --web "*facebook.com*"');
+        process.exit(1);
       }
+      
       process.exit(0);
     } catch (error) {
       console.error('Failed to add tracking pattern:', error.message);
@@ -287,7 +416,6 @@ program
         }
 
         console.log('Recording stopped successfully');
-        console.log('Output saved to:', result.outputPath);
         
         // Check if files still exist - if not, background process already uploaded
         const filesExist = fs.existsSync(result.outputPath) && 
@@ -295,8 +423,24 @@ program
                           (!result.snapshotPath || fs.existsSync(result.snapshotPath));
         
         if (!filesExist) {
-          console.log('✅ Recording was already uploaded by background process');
-          console.log('✅ Recording stopped and uploaded');
+          // Files were deleted, meaning background process uploaded
+          // Wait for the upload result to be written
+          logger.debug('Waiting for upload result from background process');
+          await new Promise(resolve => setTimeout(resolve, 2000));
+          
+          // Try to read the upload result from the background process
+          const uploadResult = processManager.readUploadResult();
+          logger.debug('Upload result read attempt', { found: !!uploadResult, shareLink: uploadResult?.shareLink });
+          
+          if (uploadResult && uploadResult.shareLink) {
+            console.log('📹 Watch your recording:', uploadResult.shareLink);
+            // Clean up the result file now that we've read it
+            processManager.cleanup();
+          } else {
+            console.log('✅ Recording uploaded (share link not available)');
+            logger.warn('Upload result not available from background process');
+          }
+          
           process.exit(0);
         }
         
@@ -315,7 +459,7 @@ program
             snapshotPath: result.snapshotPath
           });
           
-          console.log('✅ Upload complete! Share link:', uploadResult.shareLink);
+          console.log('📹 Watch your recording:', uploadResult.shareLink);
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           console.log('Recording saved locally:', result.outputPath);

package/lib/ffmpeg.js

@@ -18,8 +18,7 @@ export async function createSnapshot(inputVideoPath, outputSnapshotPath, snapsho
     '-i', inputVideoPath,
     '-frames:v', '1',
     '-vf', 'scale=640:-1:force_original_aspect_ratio=decrease:eval=frame',
-    '-pred', 'mixed',
-    '-compression_level', '100',
+    '-compression_level', '6', // Use default compression (was 100, which is extremely slow)
     outputSnapshotPath,
     '-y',
     '-hide_banner'

package/lib/logs/index.js

@@ -15,7 +15,13 @@ const CLI_CONFIG_FILE = path.join(process.cwd(), '.dashcam', 'cli-config.json');
 
 // Simple trim function for CLI (adapted from desktop app)
 async function trimLogs(groupLogStatuses, startMS, endMS, clientStartDate, clipId) {
-  logger.info('Trimming logs', { count: groupLogStatuses.length });
+  logger.info('Trimming logs', { 
+    count: groupLogStatuses.length,
+    startMS,
+    endMS,
+    clientStartDate,
+    clientStartDateReadable: new Date(clientStartDate).toISOString()
+  });
   
   const REPLAY_DIR = path.join(os.tmpdir(), 'dashcam', 'recordings');
   
@@ -36,12 +42,24 @@ async function trimLogs(groupLogStatuses, startMS, endMS, clientStartDate, clipI
       let events = content;
       
       // Convert events to relative time
-      let relativeEvents = events.map((event) => {
+      let relativeEvents = events.map((event, index) => {
+        const originalTime = event.time;
         event.time = parseInt(event.time + '') - startMS;
         // Check if it's not already relative time
         if (event.time > 1_000_000_000_000) {
           // relative time = absolute time - clip start time
           event.time = event.time - clientStartDate;
+          if (index === 0) {
+            // Log first event for debugging
+            logger.info('First event timestamp conversion', {
+              originalTime,
+              clientStartDate,
+              relativeTime: event.time,
+              relativeSeconds: (event.time / 1000).toFixed(2),
+              startMS,
+              line: event.line ? event.line.substring(0, 50) : 'N/A'
+            });
+          }
         }
         return event;
       });
@@ -56,16 +74,19 @@ async function trimLogs(groupLogStatuses, startMS, endMS, clientStartDate, clipI
         });
 
         if (status.type === 'cli') {
-          // Remap logFile indices for CLI logs
-          let map = {};
-          filteredEvents = filteredEvents.map((event) => {
-            let name = map[event.logFile] ?? Object.keys(map).length + 1;
-            if (!map[event.logFile]) map[event.logFile] = name;
-            return {
-              ...event,
-              logFile: name,
-            };
+          // For CLI logs, keep the file paths in logFile field for UI display
+          // No need to remap to numeric indices
+          
+          // Create items array showing unique files and their event counts
+          const fileCounts = {};
+          filteredEvents.forEach(event => {
+            fileCounts[event.logFile] = (fileCounts[event.logFile] || 0) + 1;
           });
+          
+          status.items = Object.entries(fileCounts).map(([filePath, count]) => ({
+            item: filePath,
+            count
+          }));
         }
       } else if (status.type === 'web' && !webHandled) {
         logger.debug('Found web groupLog, handling all web groupLogs at once');
@@ -243,6 +264,41 @@ class LogsTrackerManager {
     this.removeCliTrackedPath(filePath);
   }
 
+  addPipedLog(content) {
+    // Find active recording instance
+    const activeInstances = Object.values(this.instances);
+    if (activeInstances.length === 0) {
+      logger.warn('No active recording to add piped content to');
+      return;
+    }
+    
+    // Add to the most recent active instance (last one)
+    const instance = activeInstances[activeInstances.length - 1];
+    const timestamp = Date.now();
+    
+    // Write to CLI tracker's temp file
+    if (instance.trackers && instance.trackers.cli) {
+      const pipedLog = {
+        time: timestamp,
+        logFile: 'piped-input',
+        content: content
+      };
+      
+      // Write to the CLI tracker's output file
+      try {
+        const outputFile = path.join(instance.directory, 'cli-logs.jsonl');
+        const logLine = JSON.stringify(pipedLog) + '\n';
+        fs.appendFileSync(outputFile, logLine);
+        logger.info('Added piped content to recording', { 
+          recorderId: instance.recorderId,
+          contentLength: content.length 
+        });
+      } catch (error) {
+        logger.error('Failed to write piped content', { error });
+      }
+    }
+  }
+
   removeTracker(id) {
     // Try removing from web trackers first
     if (this.webLogsConfig[id]) {