dashcam 1.0.1-beta.26 → 1.0.1-beta.27

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);

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,66 @@ 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 (for backward compatibility if needed)
+        logger.info('Stopping active recording process', { pid });
+        process.kill(pid, 'SIGINT');
+        
+        // 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');
+          process.kill(pid, 'SIGKILL');
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        
+        if (status) {
+          logger.info('Recording stopped, returning 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: []
+          };
+          
+          this.cleanup({ preserveResult: true });
+          return result;
+        } else {
+          throw new Error('No status information available for active recording');
+        }
       }
     } catch (error) {
       logger.error('Failed to stop recording', { error });
@@ -213,67 +226,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.27",
   "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