dashcam 1.0.1-beta.26 → 1.0.1-beta.28

package/bin/dashcam.js

@@ -136,7 +136,56 @@ async function recordingAction(options, command) {
       log('Use "dashcam status" to check progress');
       log('Use "dashcam stop" to stop recording and upload');
       
-      process.exit(0);
+      // Keep the process alive so recording continues
+      // Set up graceful shutdown handlers
+      const handleShutdown = async (signal) => {
+        log(`\nReceived ${signal}, stopping recording...`);
+        try {
+          const result = await processManager.stopActiveRecording();
+          
+          if (result) {
+            log('Recording stopped successfully');
+            log('Uploading recording...');
+            
+            try {
+              const uploadResult = await upload(result.outputPath, {
+                title: options.title || 'Dashcam Recording',
+                description: description,
+                project: options.project || options.k,
+                duration: result.duration,
+                clientStartDate: result.clientStartDate,
+                apps: result.apps,
+                icons: result.icons,
+                gifPath: result.gifPath,
+                snapshotPath: result.snapshotPath
+              });
+              
+              // Write upload result for stop command to read
+              processManager.writeUploadResult({
+                shareLink: uploadResult.shareLink,
+                replayId: uploadResult.replay?.id
+              });
+              
+              log('📹 Watch your recording:', uploadResult.shareLink);
+            } catch (uploadError) {
+              logError('Upload failed:', uploadError.message);
+              log('Recording saved locally:', result.outputPath);
+            }
+          }
+          
+          process.exit(0);
+        } catch (error) {
+          logError('Failed to stop recording:', error.message);
+          process.exit(1);
+        }
+      };
+      
+      process.on('SIGINT', handleShutdown);
+      process.on('SIGTERM', handleShutdown);
+      
+      // Keep process alive indefinitely until stopped
+      await new Promise(() => {}); // Wait forever
+      
     } catch (error) {
       logError('Failed to start recording:', error.message);
       process.exit(1);
@@ -417,58 +466,43 @@ program
 
         console.log('Recording stopped successfully');
         
-        // Wait for upload to complete (background process handles this)
-        logger.debug('Waiting for background upload to complete...');
-        console.log('⏳ Uploading recording...');
-        
-        // Wait up to 2 minutes for upload result to appear
-        const maxWaitForUpload = 120000; // 2 minutes
-        const startWaitForUpload = Date.now();
-        let uploadResult = null;
-        
-        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
-          uploadResult = processManager.readUploadResult();
-          if (!uploadResult) {
-            await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
-          }
-        }
-        
-        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
+        // Check if the result already has a shareLink (from signal handler upload)
+        if (result.shareLink) {
+          console.log('📹 Watch your recording:', result.shareLink);
           processManager.cleanup();
           process.exit(0);
         }
         
-        // Check if files still exist - if not, background process already uploaded
-        const filesExist = fs.existsSync(result.outputPath) && 
-                          (!result.gifPath || fs.existsSync(result.gifPath)) && 
-                          (!result.snapshotPath || fs.existsSync(result.snapshotPath));
+        // Otherwise, check if upload result file was written
+        const uploadResultFromFile = processManager.readUploadResult();
+        logger.debug('Upload result read attempt', { found: !!uploadResultFromFile, shareLink: uploadResultFromFile?.shareLink });
         
-        if (!filesExist) {
-          console.log('✅ Recording uploaded by background process');
-          logger.info('Files were cleaned up by background process');
+        if (uploadResultFromFile && uploadResultFromFile.shareLink) {
+          console.log('📹 Watch your recording:', uploadResultFromFile.shareLink);
+          processManager.cleanup();
           process.exit(0);
         }
         
-        // Always attempt to upload - let upload function find project if needed
+        // No upload result found - need to upload ourselves
+        // This commonly happens on Windows where signal handlers work differently
+        logger.info('No upload result found, uploading now...');
         console.log('Uploading recording...');
+        
         try {
           const uploadResult = await upload(result.outputPath, {
             title: activeStatus?.options?.title,
             description: activeStatus?.options?.description,
-            project: activeStatus?.options?.project, // May be undefined, that's ok
+            project: activeStatus?.options?.project,
             duration: result.duration,
             clientStartDate: result.clientStartDate,
             apps: result.apps,
-            icons: result.icons,
+            logs: result.logs,
             gifPath: result.gifPath,
             snapshotPath: result.snapshotPath
           });
           
           console.log('📹 Watch your recording:', uploadResult.shareLink);
+          processManager.cleanup();
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           console.log('Recording saved locally:', result.outputPath);

package/lib/processManager.js

@@ -1,13 +1,8 @@
-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');
@@ -156,48 +151,121 @@ class ProcessManager {
         return false;
       }
       
-      // Recording is active, send SIGINT to trigger graceful shutdown
-      logger.info('Stopping active recording process', { pid });
-      process.kill(pid, 'SIGINT');
-      
-      // Wait for the process to actually finish and upload
-      // Increase timeout to allow for upload to complete
-      const maxWaitTime = 120000; // 2 minutes max to allow for upload
-      const startWait = Date.now();
-      
-      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-      }
-      
-      if (this.isProcessRunning(pid)) {
-        logger.warn('Process did not stop within timeout, forcing termination');
-        process.kill(pid, 'SIGKILL');
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
-      
-      // The background process handles stopRecording() internally via SIGINT
-      // We just need to return the basic result from the status file
-      if (status) {
-        logger.info('Background recording stopped, returning status', { 
-          outputPath: status.outputPath,
-          duration: Date.now() - status.startTime
-        });
+      // Check if this is the same process (direct recording)
+      if (pid === process.pid) {
+        logger.info('Stopping recording in current process');
+        
+        // Import recorder module
+        const { stopRecording: stopRecorderRecording } = await import('./recorder.js');
         
-        const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
-        const result = {
-          outputPath: status.outputPath,
-          gifPath: `${basePath}.gif`,
-          snapshotPath: `${basePath}.png`,
-          duration: Date.now() - status.startTime,
-          clientStartDate: status.startTime,
-          apps: [],
-          logs: []
-        };
+        // Stop recording directly
+        const result = await stopRecorderRecording();
+        
+        // Update status to indicate recording stopped
+        this.writeStatus({
+          isRecording: false,
+          completedTime: Date.now(),
+          pid: process.pid
+        });
         
         this.cleanup({ preserveResult: true });
         return result;
       } else {
-        throw new Error('No status information available for active recording');
+        // Different process - send signal to stop it
+        logger.info('Stopping active recording process', { pid });
+        
+        try {
+          process.kill(pid, 'SIGINT');
+        } catch (error) {
+          logger.warn('Failed to send SIGINT, process may have already exited', { error: error.message });
+        }
+        
+        // Wait for the process to actually finish
+        const maxWaitTime = 120000; // 2 minutes max
+        const startWait = Date.now();
+        
+        while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        
+        if (this.isProcessRunning(pid)) {
+          logger.warn('Process did not stop within timeout, forcing termination');
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch (error) {
+            logger.warn('Failed to send SIGKILL', { error: error.message });
+          }
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        
+        // Wait a bit for upload result file to be written by the signal handler
+        logger.debug('Waiting for upload result file...');
+        const maxWaitForUpload = 10000; // 10 seconds
+        const startWaitForUpload = Date.now();
+        let uploadResult = null;
+        
+        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
+          uploadResult = this.readUploadResult();
+          if (!uploadResult) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+          }
+        }
+        
+        // If upload result exists, the signal handler did the upload
+        if (uploadResult) {
+          logger.info('Upload completed by recording process');
+          if (status) {
+            const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
+            const result = {
+              outputPath: status.outputPath,
+              gifPath: `${basePath}.gif`,
+              snapshotPath: `${basePath}.png`,
+              duration: Date.now() - status.startTime,
+              clientStartDate: status.startTime,
+              apps: [],
+              logs: [],
+              shareLink: uploadResult.shareLink,
+              replayId: uploadResult.replayId
+            };
+            
+            this.cleanup({ preserveResult: false }); // Clean up everything including result
+            return result;
+          }
+        }
+        
+        // If no upload result, we need to handle it ourselves
+        // This can happen on Windows where signal handlers don't work the same way
+        logger.warn('No upload result found, handling upload in stop command');
+        
+        if (status) {
+          logger.info('Reconstructing result from status', { 
+            outputPath: status.outputPath,
+            duration: Date.now() - status.startTime
+          });
+          
+          const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
+          const result = {
+            outputPath: status.outputPath,
+            gifPath: `${basePath}.gif`,
+            snapshotPath: `${basePath}.png`,
+            duration: Date.now() - status.startTime,
+            clientStartDate: status.startTime,
+            apps: [],
+            logs: []
+          };
+          
+          // Don't cleanup yet - let the stop command handle upload
+          // Just update status to not recording
+          this.writeStatus({
+            isRecording: false,
+            completedTime: Date.now(),
+            pid: status.pid
+          });
+          
+          return result;
+        } else {
+          throw new Error('No status information available for active recording');
+        }
       }
     } catch (error) {
       logger.error('Failed to stop recording', { error });
@@ -213,67 +281,41 @@ class ProcessManager {
       throw new Error('Recording already in progress');
     }
 
-    // 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'
-      }
-    });
+    // Import recorder module
+    const { startRecording: startRecorderRecording } = await import('./recorder.js');
     
-    // Close the file descriptors in the parent process
-    fs.closeSync(stdoutFd);
-    fs.closeSync(stderrFd);
-
-    // Get the background process PID before unreffing
-    const backgroundPid = backgroundProcess.pid;
+    logger.info('Starting recording directly');
     
-    // Allow the parent process to exit independently
-    backgroundProcess.unref();
+    // Start recording using the recorder module
+    const recordingOptions = {
+      fps: parseInt(options.fps) || 10,
+      includeAudio: options.audio || false,
+      customOutputPath: options.output || null
+    };
 
-    // Wait a moment for the background process to initialize
-    await new Promise(resolve => setTimeout(resolve, 2000));
+    const result = await startRecorderRecording(recordingOptions);
 
-    // 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');
-    }
+    // Write status to track the recording
+    this.writeStatus({
+      isRecording: true,
+      startTime: result.startTime,
+      options,
+      pid: process.pid,
+      outputPath: result.outputPath
+    });
 
-    // Write PID file so other commands can find the background process
-    this.writePid(status.pid);
+    // Write PID file so other commands can find the recording process
+    this.writePid(process.pid);
 
-    logger.info('Background recording process started', { 
-      pid: status.pid,
-      outputPath: status.outputPath
+    logger.info('Recording started successfully', { 
+      pid: process.pid,
+      outputPath: result.outputPath
     });
 
     return {
-      pid: status.pid,
-      outputPath: status.outputPath,
-      startTime: status.startTime
+      pid: process.pid,
+      outputPath: result.outputPath,
+      startTime: result.startTime
     };
   }
 

package/package.json

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

package/test_workflow.sh

@@ -33,13 +33,16 @@ echo "✅ File tracking configured"
 # 4. Start dashcam recording in background
 echo ""
 echo "4. Starting dashcam recording in background..."
-# Start recording and redirect output to a log file so we can still monitor it
+echo "⚠️  NOTE: Recording will run in the background using nohup"
+echo ""
+
+# Use nohup to properly detach the process and keep it running
 ./bin/dashcam.js record --title "Sync Test Recording" --description "Testing video/log synchronization with timestamped events" > /tmp/dashcam-recording.log 2>&1 &
 RECORD_PID=$!
 
 # Wait for recording to initialize and log tracker to start
 echo "Waiting for recording to initialize (PID: $RECORD_PID)..."
-sleep 1
+sleep 3
 
 # Write first event after log tracker is fully ready
 RECORDING_START=$(date +%s)
@@ -48,11 +51,12 @@ echo "🔴 EVENT 1: Recording START at $(date '+%H:%M:%S')"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 echo "[EVENT 1] 🔴 Recording started with emoji at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_START" >> "$TEMP_FILE"
 
-# Verify recording is actually running
-if ps -p $RECORD_PID > /dev/null; then
+# Verify recording is actually running by checking status
+if ./bin/dashcam.js status | grep -q "Recording in progress"; then
   echo "✅ Recording started successfully"
 else
-  echo "❌ Recording process died, check /tmp/dashcam-recording.log"
+  echo "❌ Recording failed to start, check /tmp/dashcam-recording.log"
+  cat /tmp/dashcam-recording.log
   exit 1
 fi