dashcam 1.0.1-beta.6 → 1.0.1-beta.8

package/bin/dashcam-background.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * Background recording process for dashcam CLI
+ * This script runs detached from the parent process to handle long-running recordings
+ */
+
+import { startRecording, stopRecording } from '../lib/recorder.js';
+import { upload } from '../lib/uploader.js';
+import { logger, setVerbose } from '../lib/logger.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Get process directory for status files
+const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
+const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
+const RESULT_FILE = path.join(PROCESS_DIR, 'upload-result.json');
+
+// Parse options from command line argument
+const optionsJson = process.argv[2];
+if (!optionsJson) {
+  console.error('No options provided to background process');
+  process.exit(1);
+}
+
+const options = JSON.parse(optionsJson);
+
+// Enable verbose logging in background
+setVerbose(true);
+
+logger.info('Background recording process started', { 
+  pid: process.pid,
+  options 
+});
+
+// Write status file
+function writeStatus(status) {
+  try {
+    fs.writeFileSync(STATUS_FILE, JSON.stringify({
+      ...status,
+      timestamp: Date.now(),
+      pid: process.pid
+    }, null, 2));
+  } catch (error) {
+    logger.error('Failed to write status file', { error });
+  }
+}
+
+// Write upload result file
+function writeUploadResult(result) {
+  try {
+    logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
+    fs.writeFileSync(RESULT_FILE, JSON.stringify({
+      ...result,
+      timestamp: Date.now()
+    }, null, 2));
+    logger.info('Successfully wrote upload result to file');
+  } catch (error) {
+    logger.error('Failed to write upload result file', { error });
+  }
+}
+
+// Main recording function
+async function runBackgroundRecording() {
+  let recordingResult = null;
+  let isShuttingDown = false;
+
+  try {
+    // Start the recording
+    const recordingOptions = {
+      fps: parseInt(options.fps) || 10,
+      includeAudio: options.audio || false,
+      customOutputPath: options.output || null
+    };
+
+    logger.info('Starting recording with options', { recordingOptions });
+
+    recordingResult = await startRecording(recordingOptions);
+
+    // Write status to track the recording
+    writeStatus({
+      isRecording: true,
+      startTime: recordingResult.startTime,
+      options,
+      pid: process.pid,
+      outputPath: recordingResult.outputPath
+    });
+
+    logger.info('Recording started successfully', { 
+      outputPath: recordingResult.outputPath,
+      startTime: recordingResult.startTime 
+    });
+
+    // Set up signal handlers for graceful shutdown
+    const handleShutdown = async (signal) => {
+      if (isShuttingDown) {
+        logger.info('Shutdown already in progress...');
+        return;
+      }
+      isShuttingDown = true;
+      
+      logger.info(`Received ${signal}, stopping background recording...`);
+      
+      try {
+        // Stop the recording
+        const stopResult = await stopRecording();
+        
+        if (stopResult) {
+          logger.info('Recording stopped successfully', { 
+            outputPath: stopResult.outputPath,
+            duration: stopResult.duration 
+          });
+          
+          // Upload the recording
+          logger.info('Starting upload...');
+          const uploadResult = await upload(stopResult.outputPath, {
+            title: options.title || 'Dashcam Recording',
+            description: options.description || 'Recorded with Dashcam CLI',
+            project: options.project || options.k,
+            duration: stopResult.duration,
+            clientStartDate: stopResult.clientStartDate,
+            apps: stopResult.apps,
+            logs: stopResult.logs,
+            gifPath: stopResult.gifPath,
+            snapshotPath: stopResult.snapshotPath
+          });
+          
+          logger.info('Upload complete', { shareLink: uploadResult.shareLink });
+          
+          // Write upload result for stop command to read
+          writeUploadResult({
+            shareLink: uploadResult.shareLink,
+            replayId: uploadResult.replay?.id
+          });
+        }
+        
+        // Update status to indicate recording stopped
+        writeStatus({
+          isRecording: false,
+          completedTime: Date.now(),
+          pid: process.pid
+        });
+        
+        logger.info('Background process exiting successfully');
+        process.exit(0);
+      } catch (error) {
+        logger.error('Error during shutdown:', error);
+        process.exit(1);
+      }
+    };
+    
+    process.on('SIGINT', () => handleShutdown('SIGINT'));
+    process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+    
+    // Keep the process alive
+    logger.info('Background recording is now running. Waiting for stop signal...');
+    await new Promise(() => {}); // Wait indefinitely for signals
+    
+  } catch (error) {
+    logger.error('Background recording failed:', error);
+    
+    // Update status to indicate failure
+    writeStatus({
+      isRecording: false,
+      error: error.message,
+      pid: process.pid
+    });
+    
+    process.exit(1);
+  }
+}
+
+// Run the background recording
+runBackgroundRecording().catch(error => {
+  logger.error('Fatal error in background process:', error);
+  process.exit(1);
+});

package/bin/dashcam.js

@@ -117,8 +117,8 @@ async function recordingAction(options, command) {
       process.exit(1);
     }
 
-    // Always use background mode
-    log('Starting recording...');
+    // Start recording in background mode
+    log('Starting recording in background...');
     
     try {
       const result = await processManager.startRecording({
@@ -130,81 +130,13 @@ async function recordingAction(options, command) {
         project: options.project || options.k // Support both -p and -k for project
       });
 
-      log(`Recording started successfully (PID: ${result.pid})`);
+      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');
       
-      // Keep this process alive for background recording
-      log('Recording is running in background...');
-      
-      // Set up signal handlers for graceful shutdown
-      let isShuttingDown = false;
-      const handleShutdown = async (signal) => {
-        if (isShuttingDown) {
-          log('Shutdown already in progress...');
-          return;
-        }
-        isShuttingDown = true;
-        
-        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) {
-            log('Recording stopped:', stopResult.outputPath);
-            
-            // Import and call upload function with the correct format
-            const { upload } = await import('../lib/uploader.js');
-            
-            log('Starting upload...');
-            const uploadResult = await upload(stopResult.outputPath, {
-              title: options.title || 'Dashcam Recording',
-              description: description || 'Recorded with Dashcam CLI',
-              project: options.project || options.k,
-              duration: stopResult.duration,
-              clientStartDate: stopResult.clientStartDate,
-              apps: stopResult.apps,
-              logs: stopResult.logs,
-              gifPath: stopResult.gifPath,
-              snapshotPath: stopResult.snapshotPath
-            });
-            
-            // Write upload result for stop command to read
-            processManager.writeUploadResult({
-              shareLink: uploadResult.shareLink,
-              replayId: uploadResult.replay?.id
-            });
-            
-            // Output based on format option (for create/markdown mode)
-            if (options.md) {
-              const replayId = uploadResult.replay?.id;
-              const shareKey = uploadResult.shareLink.split('share=')[1];
-              log(`[![Dashcam - ${options.title || 'New Replay'}](https://replayable-api-production.herokuapp.com/replay/${replayId}/gif?shareKey=${shareKey})](${uploadResult.shareLink})`);
-              log('');
-              log(`Watch [Dashcam - ${options.title || 'New Replay'}](${uploadResult.shareLink}) on Dashcam`);
-            } else {
-              log('✅ Upload complete!');
-              log('📹 Watch your recording:', uploadResult.shareLink);
-            }
-          }
-          
-          // Clean up process files, but preserve upload result for stop command
-          processManager.cleanup({ preserveResult: true });
-        } catch (error) {
-          logError('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(() => {});
+      process.exit(0);
     } catch (error) {
       logError('Failed to start recording:', error.message);
       process.exit(1);

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/processManager.js

@@ -2,8 +2,12 @@ import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 // Use a fixed directory in the user's home directory for cross-process communication
 const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
 const PID_FILE = path.join(PROCESS_DIR, 'recording.pid');
@@ -222,44 +226,68 @@ class ProcessManager {
       throw new Error('Recording already in progress');
     }
 
-    try {
-      // Import and call the recording function directly
-      const { startRecording } = await import('./recorder.js');
-      
-      const recordingOptions = {
-        fps: parseInt(options.fps) || 10,
-        includeAudio: options.audio || false,
-        customOutputPath: options.output || null
-      };
+    // Always run in background mode by spawning a detached process
+    logger.info('Starting recording in background mode');
+    
+    // Get the path to the CLI binary
+    const binPath = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
+    
+    logger.debug('Background process path', { binPath, exists: fs.existsSync(binPath) });
+    
+    // Create log files for background process
+    const logDir = PROCESS_DIR;
+    const stdoutLog = path.join(logDir, 'background-stdout.log');
+    const stderrLog = path.join(logDir, 'background-stderr.log');
+    
+    const stdoutFd = fs.openSync(stdoutLog, 'a');
+    const stderrFd = fs.openSync(stderrLog, 'a');
+    
+    // Spawn a detached process that will handle the recording
+    const backgroundProcess = spawn(process.execPath, [
+      binPath,
+      JSON.stringify(options)
+    ], {
+      detached: true,
+      stdio: ['ignore', stdoutFd, stderrFd], // Log stdout and stderr
+      env: {
+        ...process.env,
+        DASHCAM_BACKGROUND: 'true'
+      }
+    });
+    
+    // Close the file descriptors in the parent process
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
 
-      logger.info('Starting recording directly', { options: recordingOptions });
+    // Get the background process PID before unreffing
+    const backgroundPid = backgroundProcess.pid;
+    
+    // Allow the parent process to exit independently
+    backgroundProcess.unref();
 
-      const result = await startRecording(recordingOptions);
+    // Wait a moment for the background process to initialize
+    await new Promise(resolve => setTimeout(resolve, 2000));
 
-      // Write status to track the recording
-      this.writePid(process.pid);
-      this.writeStatus({
-        isRecording: true,
-        startTime: result.startTime, // Use actual recording start time from recorder
-        options,
-        pid: process.pid,
-        outputPath: result.outputPath
-      });
+    // Read the status file to get recording details
+    const status = this.readStatus();
+    
+    if (!status || !status.isRecording) {
+      throw new Error('Background process failed to start recording');
+    }
 
-      logger.info('Recording started successfully', { 
-        outputPath: result.outputPath,
-        startTime: result.startTime 
-      });
+    // Write PID file so other commands can find the background process
+    this.writePid(status.pid);
 
-      return {
-        pid: process.pid,
-        outputPath: result.outputPath,
-        startTime: result.startTime
-      };
-    } catch (error) {
-      logger.error('Failed to start recording', { error });
-      throw error;
-    }
+    logger.info('Background recording process started', { 
+      pid: status.pid,
+      outputPath: status.outputPath
+    });
+
+    return {
+      pid: status.pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime
+    };
   }
 
   async gracefulExit() {

package/lib/recorder.js

@@ -279,13 +279,13 @@ export async function startRecording({
   const platformArgs = await getPlatformArgs({ fps, includeAudio });
   const outputArgs = [
     '-c:v', 'libvpx-vp9',  // Use VP9 codec for better quality and compression
-    '-quality', 'good',    // Use good quality preset for better encoding
-    '-cpu-used', '2',      // Higher quality encoding (0-5, lower = slower but better quality)
-    '-deadline', 'good',   // Good quality encoding mode
-    '-b:v', '5M',          // Higher bitrate for better quality
+    '-quality', 'realtime', // Use realtime quality preset for lower CPU usage
+    '-cpu-used', '5',      // Faster encoding (0-5, higher = faster but lower quality)
+    '-deadline', 'realtime', // Realtime encoding mode for lower latency/CPU
+    '-b:v', '2M',          // Lower bitrate to reduce CPU load (was 5M)
     // Remove explicit pixel format to let ffmpeg handle conversion automatically
     '-r', fps.toString(),   // Ensure output framerate matches input
-    '-g', '30',            // Keyframe every 30 frames
+    '-g', '60',            // Keyframe every 60 frames (reduced frequency)
     // WebM options for more frequent disk writes
     '-f', 'webm',          // Force WebM container format
     '-flush_packets', '1', // Flush packets immediately to disk

package/lib/uploader.js

@@ -445,8 +445,7 @@ export async function upload(filePath, metadata = {}) {
 
   logExit();
   
-  // Replace app.dashcam.io with app.testdriver.ai in the share link
-  const shareLink = newReplay.replay.shareLink?.replace('app.dashcam.io', 'app.testdriver.ai') || newReplay.replay.shareLink;
+  const shareLink = newReplay.replay.shareLink;
   
   return {
     replay: newReplay.replay,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.0.1-beta.6",
+  "version": "1.0.1-beta.8",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/index.js",
   "bin": {