dashcam 1.0.1-beta.35 → 1.0.1-beta.36

package/bin/dashcam-background.js

@@ -15,6 +15,7 @@ import os from 'os';
 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');
+const STOP_SIGNAL_FILE = path.join(PROCESS_DIR, 'stop-signal.json');
 
 // Parse options from command line argument
 const optionsJson = process.argv[2];
@@ -96,79 +97,74 @@ async function runBackgroundRecording() {
       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} signal, stopping background recording...`, { pid: process.pid });
-      
+    // Poll for stop signal file instead of relying on system signals
+    // This works reliably across all platforms including Windows
+    logger.info('Background recording is now running. Polling for stop signal...');
+    
+    const pollInterval = 1000; // Check every second
+    
+    while (true) {
       try {
-        // Stop the recording
-        logger.info('Calling stopRecording...');
-        const stopResult = await stopRecording();
-        
-        if (stopResult) {
-          logger.info('Recording stopped successfully', { 
-            outputPath: stopResult.outputPath,
-            duration: stopResult.duration 
-          });
+        if (fs.existsSync(STOP_SIGNAL_FILE)) {
+          if (isShuttingDown) {
+            logger.info('Shutdown already in progress...');
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            continue;
+          }
+          isShuttingDown = true;
           
-          // 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('Stop signal file detected, initiating graceful shutdown');
+          
+          // Read and log the signal
+          try {
+            const signalData = JSON.parse(fs.readFileSync(STOP_SIGNAL_FILE, 'utf8'));
+            logger.info('Stop signal received', signalData);
+          } catch (e) {
+            logger.warn('Could not parse stop signal file');
+          }
+          
+          // Stop the recording
+          logger.info('Calling stopRecording...');
+          const stopResult = await stopRecording();
           
-          logger.info('Upload complete', { shareLink: uploadResult.shareLink });
+          if (stopResult) {
+            logger.info('Recording stopped successfully', { 
+              outputPath: stopResult.outputPath,
+              duration: stopResult.duration 
+            });
+            
+            // Write the recording result so stop command can upload it
+            logger.info('Writing recording result for stop command to upload');
+            writeUploadResult({
+              outputPath: stopResult.outputPath,
+              duration: stopResult.duration,
+              clientStartDate: stopResult.clientStartDate,
+              apps: stopResult.apps,
+              logs: stopResult.logs,
+              gifPath: stopResult.gifPath,
+              snapshotPath: stopResult.snapshotPath,
+              recordingStopped: true
+            });
+            logger.info('Recording result written successfully');
+          }
           
-          // Write upload result for stop command to read
-          logger.info('About to write upload result...');
-          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('Upload result written successfully');
+          
+          logger.info('Background process exiting successfully');
+          process.exit(0);
         }
-        
-        // 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: error.message, stack: error.stack });
-        process.exit(1);
+        logger.error('Error during stop signal handling', { error: error.message, stack: error.stack });
       }
-    };
-    
-    process.on('SIGINT', () => {
-      logger.info('SIGINT handler triggered');
-      handleShutdown('SIGINT');
-    });
-    process.on('SIGTERM', () => {
-      logger.info('SIGTERM handler triggered');
-      handleShutdown('SIGTERM');
-    });
-    
-    // Keep the process alive
-    logger.info('Background recording is now running. Waiting for stop signal...');
-    await new Promise(() => {}); // Wait indefinitely for signals
+      
+      // Wait before next poll
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
     
   } catch (error) {
     logger.error('Background recording failed:', error);

package/bin/dashcam.js

@@ -419,61 +419,56 @@ 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 for background process to finish recording and write result
+        logger.debug('Waiting for background process to finish recording...');
         
-        // Wait up to 2 minutes for upload result to appear
-        const maxWaitForUpload = 120000; // 2 minutes
-        const startWaitForUpload = Date.now();
-        let uploadResult = null;
+        // Wait up to 30 seconds for recording result to appear
+        const maxWaitForRecording = 30000;
+        const startWaitForRecording = Date.now();
+        let recordingResult = null;
         
-        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
-          uploadResult = processManager.readUploadResult();
-          if (!uploadResult) {
-            await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
+        while (!recordingResult && (Date.now() - startWaitForRecording) < maxWaitForRecording) {
+          const resultData = processManager.readUploadResult();
+          if (resultData && resultData.recordingStopped) {
+            recordingResult = resultData;
+            logger.debug('Recording result received from background process');
+            break;
           }
+          await new Promise(resolve => setTimeout(resolve, 500)); // Check every 500ms
         }
         
-        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();
-          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));
-        
-        if (!filesExist) {
-          console.log('✅ Recording uploaded by background process');
-          logger.info('Files were cleaned up by background process');
-          process.exit(0);
+        if (!recordingResult || !recordingResult.outputPath) {
+          logger.error('Failed to get recording result from background process');
+          console.log('⚠️  Failed to get recording from background process');
+          process.exit(1);
         }
         
-        // Always attempt to upload - let upload function find project if needed
+        // Now upload the recording ourselves
+        logger.info('Uploading recording from stop command', { outputPath: recordingResult.outputPath });
         console.log('Uploading recording...');
+        
         try {
-          const uploadResult = await upload(result.outputPath, {
-            title: activeStatus?.options?.title,
+          const uploadResult = await upload(recordingResult.outputPath, {
+            title: activeStatus?.options?.title || 'Dashcam Recording',
             description: activeStatus?.options?.description,
-            project: activeStatus?.options?.project, // May be undefined, that's ok
-            duration: result.duration,
-            clientStartDate: result.clientStartDate,
-            apps: result.apps,
-            icons: result.icons,
-            gifPath: result.gifPath,
-            snapshotPath: result.snapshotPath
+            project: activeStatus?.options?.project,
+            duration: recordingResult.duration,
+            clientStartDate: recordingResult.clientStartDate,
+            apps: recordingResult.apps,
+            logs: recordingResult.logs,
+            gifPath: recordingResult.gifPath,
+            snapshotPath: recordingResult.snapshotPath
           });
           
           console.log('📹 Watch your recording:', uploadResult.shareLink);
+          
+          // Clean up result file
+          processManager.cleanup();
+          process.exit(0);
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
-          console.log('Recording saved locally:', result.outputPath);
+          console.log('Recording saved locally:', recordingResult.outputPath);
+          process.exit(1);
         }
       } catch (error) {
         console.error('Failed to stop recording:', error.message);

package/lib/processManager.js

@@ -9,6 +9,7 @@ import { logger } from './logger.js';
 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');
+const STOP_SIGNAL_FILE = path.join(PROCESS_DIR, 'stop-signal.json');
 
 // Ensure process directory exists
 if (!fs.existsSync(PROCESS_DIR)) {
@@ -121,6 +122,10 @@ class ProcessManager {
         fs.unlinkSync(STATUS_FILE);
         logger.debug('Deleted STATUS file');
       }
+      if (fs.existsSync(STOP_SIGNAL_FILE)) {
+        fs.unlinkSync(STOP_SIGNAL_FILE);
+        logger.debug('Deleted STOP_SIGNAL file');
+      }
       if (!preserveResult && fs.existsSync(RESULT_FILE)) {
         fs.unlinkSync(RESULT_FILE);
         logger.debug('Deleted RESULT file');
@@ -148,41 +153,27 @@ class ProcessManager {
         return false;
       }
       
-      const pid = status.pid;
-      logger.info('Stopping background recording process', { pid, hasStoredPid: !!pid });
+      logger.info('Signaling background process to stop recording');
       
-      // Try to gracefully stop the process if we have a PID
-      if (pid) {
-        const isWindows = process.platform === 'win32';
-        
-        if (isWindows) {
-          logger.info('Windows detected, attempting graceful shutdown first');
-          try {
-            const { execSync } = await import('child_process');
-            try {
-              execSync(`taskkill /PID ${pid} /T`, { stdio: 'ignore', timeout: 5000 });
-              logger.info('Sent graceful shutdown signal to process');
-            } catch (error) {
-              logger.warn('Graceful shutdown failed, forcing termination');
-              execSync(`taskkill /PID ${pid} /F /T`, { stdio: 'ignore' });
-            }
-          } catch (error) {
-            logger.warn('Failed to kill process with taskkill', { error: error.message });
-          }
-        } else {
-          try {
-            process.kill(pid, 'SIGINT');
-          } catch (error) {
-            logger.warn('Failed to send SIGINT', { error: error.message });
-          }
-        }
+      // Write stop signal file instead of killing the process
+      // The background process polls for this file
+      try {
+        fs.writeFileSync(STOP_SIGNAL_FILE, JSON.stringify({
+          timestamp: Date.now(),
+          requestedBy: 'stop-command'
+        }));
+        logger.info('Stop signal file written successfully');
+      } catch (error) {
+        logger.error('Failed to write stop signal file', { error: error.message });
+        throw new Error('Failed to signal background process to stop');
       }
       
-      // Mark recording as stopped in status file immediately
+      // Mark recording as stopping in status file
       this.writeStatus({
         isRecording: false,
+        stopping: true,
         stoppedAt: Date.now(),
-        pid: pid
+        pid: status.pid
       });
       
       if (status) {
@@ -202,7 +193,8 @@ class ProcessManager {
           logs: []
         };
         
-        this.cleanup({ preserveResult: true });
+        // Don't cleanup here - the background process needs to read the stop signal file
+        // Cleanup will happen after we get the recording result
         return result;
       } else {
         throw new Error('No status information available for active recording');

package/package.json

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