dashcam 1.0.1-beta.34 → 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

@@ -7,9 +7,9 @@ import { logger } from './logger.js';
 
 // 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');
 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)) {
@@ -42,7 +42,15 @@ class ProcessManager {
     try {
       if (!fs.existsSync(STATUS_FILE)) return null;
       const data = fs.readFileSync(STATUS_FILE, 'utf8');
-      return JSON.parse(data);
+      const status = JSON.parse(data);
+      
+      // Check if status is stale (older than 24 hours)
+      if (status.timestamp && (Date.now() - status.timestamp) > 24 * 60 * 60 * 1000) {
+        logger.warn('Status file is stale, ignoring');
+        return null;
+      }
+      
+      return status;
     } catch (error) {
       logger.error('Failed to read status file', { error });
       return null;
@@ -83,45 +91,22 @@ class ProcessManager {
     }
   }
 
-  writePid(pid = process.pid) {
-    try {
-      fs.writeFileSync(PID_FILE, pid.toString());
-    } catch (error) {
-      logger.error('Failed to write PID file', { error });
-    }
-  }
-
-  readPid() {
-    try {
-      if (!fs.existsSync(PID_FILE)) return null;
-      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
-      return isNaN(pid) ? null : pid;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  isProcessRunning(pid) {
-    if (!pid) return false;
-    try {
-      process.kill(pid, 0); // Signal 0 just checks if process exists
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-
   isRecordingActive() {
-    const pid = this.readPid();
     const status = this.readStatus();
     
-    if (!pid || !this.isProcessRunning(pid)) {
-      // Clean up but preserve upload result in case the background process just finished uploading
+    // Recording is active if we have a status file with isRecording=true
+    // and it's not stale
+    if (status && status.isRecording) {
+      return true;
+    }
+    
+    // Clean up stale files if recording is not active
+    if (!status || !status.isRecording) {
       this.cleanup({ preserveResult: true });
       return false;
     }
     
-    return status && status.isRecording;
+    return false;
   }
 
   getActiveStatus() {
@@ -133,14 +118,14 @@ class ProcessManager {
     const { preserveResult = false } = options;
     try {
       logger.debug('Cleanup called', { preserveResult, resultFileExists: fs.existsSync(RESULT_FILE) });
-      if (fs.existsSync(PID_FILE)) {
-        fs.unlinkSync(PID_FILE);
-        logger.debug('Deleted PID file');
-      }
       if (fs.existsSync(STATUS_FILE)) {
         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');
@@ -161,63 +146,35 @@ class ProcessManager {
     this.isStopping = true;
     
     try {
-      const pid = this.readPid();
       const status = this.readStatus();
       
-      if (!pid || !this.isProcessRunning(pid)) {
-        logger.warn('No active recording process found');
+      if (!status || !status.isRecording) {
+        logger.warn('No active recording found in status file');
         return false;
       }
       
-      logger.info('Stopping detached background process', { pid });
-      
-      // Send signal to background process
-      const isWindows = process.platform === 'win32';
-      
-      if (isWindows) {
-        logger.info('Windows detected, attempting graceful shutdown first');
-        try {
-          // First try graceful shutdown without /F (force) flag
-          // This sends CTRL+C which Node.js can handle
-          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) {
-            // If graceful shutdown fails or times out, force kill
-            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 });
-        }
-      }
-      
-      // Wait for the process to actually finish
-      const maxWaitTime = 30000; // 30 seconds
-      const startWait = Date.now();
+      logger.info('Signaling background process to stop recording');
       
-      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
-        await new Promise(resolve => setTimeout(resolve, 500));
+      // 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');
       }
       
-      if (this.isProcessRunning(pid)) {
-        logger.warn('Process did not stop within timeout');
-        if (!isWindows) {
-          try {
-            process.kill(pid, 'SIGKILL');
-          } catch (error) {
-            logger.warn('Failed to send SIGKILL', { error: error.message });
-          }
-          await new Promise(resolve => setTimeout(resolve, 1000));
-        }
-      }
+      // Mark recording as stopping in status file
+      this.writeStatus({
+        isRecording: false,
+        stopping: true,
+        stoppedAt: Date.now(),
+        pid: status.pid
+      });
       
       if (status) {
         logger.info('Recording stopped, returning status', { 
@@ -236,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');
@@ -272,9 +230,6 @@ class ProcessManager {
     child.unref();
     
     const pid = child.pid;
-    
-    // Write PID file immediately so other commands can find the recording process
-    this.writePid(pid);
 
     logger.info('Background process spawned successfully', { 
       pid,
@@ -282,17 +237,24 @@ class ProcessManager {
     });
     
     // Wait a moment for the background process to write its status
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await new Promise(resolve => setTimeout(resolve, 1500));
     
     // Read the status to get output path and start time
     const status = this.readStatus();
     
     if (!status) {
+      logger.error('Background process failed to write status');
       throw new Error('Background process failed to write status');
     }
 
+    logger.info('Recording started successfully', { 
+      pid: status.pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime
+    });
+
     return {
-      pid,
+      pid: status.pid,
       outputPath: status.outputPath,
       startTime: status.startTime
     };

package/package.json

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