dashcam 1.3.4-beta → 1.3.6-beta

package/bin/dashcam.js

@@ -109,7 +109,7 @@ async function recordingAction(options, command) {
       }, 2000))
     ]);
     if (!hasPermissions) {
-      log('\n⚠️  Cannot start recording without screen recording permission.');
+      log('\nCannot start recording without screen recording permission.');
       process.exit(1);
     }
 
@@ -134,13 +134,17 @@ async function recordingAction(options, command) {
       
       const result = await Promise.race([startRecordingPromise, timeoutPromise]);
 
-      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');
       
-      process.exit(0);
+      // Force immediate exit - don't wait for event loop to drain
+      // This is necessary when called from scripts/automation
+      setImmediate(() => {
+        process.exit(0);
+      });
     } catch (error) {
       logError('Failed to start recording:', error.message);
       process.exit(1);
@@ -413,7 +417,7 @@ program
         
         // Wait for upload to complete (background process handles this)
         logger.debug('Waiting for background upload to complete...');
-        console.log('⏳ Uploading recording...');
+        console.log('Uploading recording...');
         
         // Wait up to 2 minutes for upload result to appear
         const maxWaitForUpload = 120000; // 2 minutes
@@ -430,7 +434,7 @@ program
         logger.debug('Upload result read attempt', { found: !!uploadResult, shareLink: uploadResult?.shareLink });
         
         if (uploadResult && uploadResult.shareLink) {
-          console.log('📹 Watch your recording:', uploadResult.shareLink);
+          console.log('Watch your recording:', uploadResult.shareLink);
           // Clean up the result file now that we've read it
           processManager.cleanup();
           process.exit(0);
@@ -442,7 +446,7 @@ program
                           (!result.snapshotPath || fs.existsSync(result.snapshotPath));
         
         if (!filesExist) {
-          console.log('✅ Recording uploaded by background process');
+          console.log('Recording uploaded by background process');
           logger.info('Files were cleaned up by background process');
           process.exit(0);
         }
@@ -462,7 +466,7 @@ program
             snapshotPath: result.snapshotPath
           });
           
-          console.log('📹 Watch your recording:', uploadResult.shareLink);
+          console.log('Watch your recording:', uploadResult.shareLink);
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           console.log('Recording saved locally:', result.outputPath);
@@ -677,7 +681,7 @@ program
         project: options.project
       });
       
-      console.log('✅ Upload complete! Share link:', uploadResult.shareLink);
+      console.log('> Upload complete! Share link:', uploadResult.shareLink);
       process.exit(0);
       
     } catch (error) {

package/lib/processManager.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
 import { logger } from './logger.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -148,35 +149,57 @@ class ProcessManager {
     
     try {
       const status = this.readStatus();
+      const pid = this.readPid();
       
       if (!status || !status.isRecording) {
         logger.warn('No active recording found');
         return false;
       }
       
-      // Import recorder module
-      const { stopRecording } = await import('./recorder.js');
+      if (!pid || !this.isProcessRunning(pid)) {
+        logger.warn('Background process not running');
+        this.cleanup({ preserveResult: true });
+        return false;
+      }
       
-      logger.info('Stopping recording directly');
+      logger.info('Sending stop signal to background process', { pid });
       
-      // Stop the recording
-      const result = await stopRecording();
+      // Send SIGTERM to the background process to trigger graceful shutdown
+      try {
+        process.kill(pid, 'SIGTERM');
+        logger.info('Sent SIGTERM to background process');
+      } catch (error) {
+        logger.error('Failed to send signal to background process', { error });
+        throw new Error('Failed to stop background recording process');
+      }
       
-      logger.info('Recording stopped successfully', { 
-        outputPath: result.outputPath,
-        duration: result.duration 
-      });
+      // Wait for the background process to finish and write results
+      logger.debug('Waiting for background process to complete...');
+      const maxWaitTime = 30000; // 30 seconds
+      const startWait = Date.now();
       
-      // Update status to indicate recording stopped
-      this.writeStatus({
-        isRecording: false,
-        completedTime: Date.now(),
-        pid: process.pid
-      });
+      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      }
       
-      this.cleanup({ preserveResult: true });
+      if (this.isProcessRunning(pid)) {
+        logger.error('Background process did not exit within timeout, forcing kill');
+        try {
+          process.kill(pid, 'SIGKILL');
+        } catch (error) {
+          logger.error('Failed to force kill background process', { error });
+        }
+      }
+      
+      logger.info('Background process stopped');
+      
+      // Return a minimal result indicating success
+      // The upload will be handled by the stop command checking the result file
+      return {
+        outputPath: status.outputPath,
+        duration: Date.now() - status.startTime
+      };
       
-      return result;
     } catch (error) {
       logger.error('Failed to stop recording', { error });
       throw error;
@@ -191,42 +214,90 @@ class ProcessManager {
       throw new Error('Recording already in progress');
     }
 
-    // Import recorder module
-    const { startRecording } = await import('./recorder.js');
+    // Spawn background process
+    const backgroundScriptPath = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
     
-    logger.info('Starting recording directly');
-    
-    // Start recording with the provided options
-    const recordingOptions = {
-      fps: parseInt(options.fps) || 10,
-      includeAudio: options.audio || false,
-      customOutputPath: options.output || null
-    };
-
-    logger.info('Starting recording with options', { recordingOptions });
+    logger.info('Starting background recording process', { 
+      backgroundScriptPath,
+      options 
+    });
 
-    const recordingResult = await startRecording(recordingOptions);
+    // Serialize options to pass to background process
+    const optionsJson = JSON.stringify(options);
     
-    // Write PID and status files for status tracking
-    this.writePid(process.pid);
+    // Determine node executable path
+    const nodePath = process.execPath;
+    
+    // Create log file for background process output
+    const logDir = path.join(PROCESS_DIR, 'logs');
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    const logFile = path.join(logDir, `recording-${Date.now()}.log`);
+    const logStream = fs.createWriteStream(logFile, { flags: 'a' });
     
-    this.writeStatus({
-      isRecording: true,
-      startTime: recordingResult.startTime,
-      options,
-      pid: process.pid,
-      outputPath: recordingResult.outputPath
+    logger.info('Background process log file', { logFile });
+    
+    // Spawn the background process with proper detachment
+    const child = spawn(
+      nodePath,
+      [backgroundScriptPath, optionsJson],
+      {
+        detached: true,    // Detach from parent on Unix-like systems
+        stdio: ['ignore', logStream, logStream], // Redirect output to log file
+        windowsHide: true, // Hide console window on Windows
+        shell: false       // Don't use shell to avoid extra process wrapper
+      }
+    );
+    
+    // Unref to allow parent to exit independently
+    child.unref();
+    
+    const pid = child.pid;
+    
+    logger.info('Background process spawned', { 
+      pid,
+      logFile,
+      detached: true
     });
-
-    logger.info('Recording started successfully', { 
-      outputPath: recordingResult.outputPath,
-      startTime: recordingResult.startTime 
+    
+    // Wait for status file to be created by background process
+    logger.debug('Waiting for background process to write status file...');
+    const maxWaitTime = 10000; // 10 seconds
+    const startWait = Date.now();
+    let statusCreated = false;
+    
+    while (!statusCreated && (Date.now() - startWait) < maxWaitTime) {
+      const status = this.readStatus();
+      if (status && status.isRecording && status.pid === pid) {
+        statusCreated = true;
+        logger.debug('Status file created by background process', { status });
+        break;
+      }
+      // Wait a bit before checking again
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    
+    if (!statusCreated) {
+      logger.error('Background process did not create status file within timeout');
+      throw new Error('Failed to start background recording process - status file not created. Check log: ' + logFile);
+    }
+    
+    // Read the status to get output path and start time
+    const status = this.readStatus();
+    
+    logger.info('Recording started successfully in background', { 
+      pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime,
+      logFile
     });
 
     return {
-      pid: process.pid,
-      outputPath: recordingResult.outputPath,
-      startTime: recordingResult.startTime
+      pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime,
+      logFile
     };
   }
 

package/lib/recorder.js

@@ -405,9 +405,21 @@ export async function startRecording({
     currentRecording = execa(ffmpegPath, args, {
       reject: false,
       all: true, // Capture both stdout and stderr
-      stdin: 'pipe' // Enable stdin for sending 'q' to stop recording
+      stdin: 'pipe', // Enable stdin for sending 'q' to stop recording
+      detached: false,
+      windowsHide: true // Hide the console window on Windows
     });
     
+    // Unref the child process so it doesn't keep the parent alive
+    if (currentRecording.pid) {
+      try {
+        currentRecording.unref();
+      } catch (e) {
+        // Ignore errors if unref is not available
+        logger.debug('Could not unref ffmpeg process');
+      }
+    }
+    
     logger.info('FFmpeg process spawned', { 
       pid: currentRecording.pid,
       args: args.slice(-5), // Log last 5 args including output file

package/lib/websocket/server.js

@@ -56,6 +56,13 @@ class WSServer {
       const ws = await new Promise((resolve) => {
         logger.debug('WebSocketServer: Trying port ' + port);
         const ws = new WebSocketServer({ port, host: '127.0.0.1' });
+        
+        // Unref the server to prevent it from keeping the process alive
+        if (ws._server && ws._server.unref) {
+          ws._server.unref();
+          logger.debug('WebSocketServer: Unreffed server to allow process exit');
+        }
+        
         ws.on('error', () => {
           logger.debug('WebSocketServer: Failed to listen on port ' + port);
           resolve();

package/package.json

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