dashcam 1.0.1-beta.33 → 1.0.1-beta.35

package/bin/dashcam-background.js

@@ -55,8 +55,13 @@ function writeUploadResult(result) {
       timestamp: Date.now()
     }, null, 2));
     logger.info('Successfully wrote upload result to file');
+    // Verify the file was written
+    if (fs.existsSync(RESULT_FILE)) {
+      const content = fs.readFileSync(RESULT_FILE, 'utf8');
+      logger.info('Verified upload result file exists and contains', { content: content.substring(0, 100) });
+    }
   } catch (error) {
-    logger.error('Failed to write upload result file', { error });
+    logger.error('Failed to write upload result file', { error: error.message, stack: error.stack });
   }
 }
 
@@ -99,10 +104,11 @@ async function runBackgroundRecording() {
       }
       isShuttingDown = true;
       
-      logger.info(`Received ${signal}, stopping background recording...`);
+      logger.info(`Received ${signal} signal, stopping background recording...`, { pid: process.pid });
       
       try {
         // Stop the recording
+        logger.info('Calling stopRecording...');
         const stopResult = await stopRecording();
         
         if (stopResult) {
@@ -128,10 +134,12 @@ async function runBackgroundRecording() {
           logger.info('Upload complete', { shareLink: uploadResult.shareLink });
           
           // Write upload result for stop command to read
+          logger.info('About to write upload result...');
           writeUploadResult({
             shareLink: uploadResult.shareLink,
             replayId: uploadResult.replay?.id
           });
+          logger.info('Upload result written successfully');
         }
         
         // Update status to indicate recording stopped
@@ -144,13 +152,19 @@ async function runBackgroundRecording() {
         logger.info('Background process exiting successfully');
         process.exit(0);
       } catch (error) {
-        logger.error('Error during shutdown:', error);
+        logger.error('Error during shutdown:', { error: error.message, stack: error.stack });
         process.exit(1);
       }
     };
     
-    process.on('SIGINT', () => handleShutdown('SIGINT'));
-    process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+    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...');

package/lib/processManager.js

@@ -7,7 +7,6 @@ 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');
 
@@ -42,7 +41,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;
@@ -59,65 +66,46 @@ class ProcessManager {
       logger.info('Successfully wrote upload result to file');
       // Verify it was written
       if (fs.existsSync(RESULT_FILE)) {
-        logger.info('Verified upload result file exists');
+        const fileSize = fs.statSync(RESULT_FILE).size;
+        logger.info('Verified upload result file exists', { size: fileSize });
       } else {
         logger.error('Upload result file does not exist after write!');
       }
     } catch (error) {
-      logger.error('Failed to write upload result file', { error });
+      logger.error('Failed to write upload result file', { error: error.message, stack: error.stack });
     }
   }
 
   readUploadResult() {
     try {
+      logger.debug('Checking for upload result file', { path: RESULT_FILE, exists: fs.existsSync(RESULT_FILE) });
       if (!fs.existsSync(RESULT_FILE)) return null;
       const data = fs.readFileSync(RESULT_FILE, 'utf8');
-      return JSON.parse(data);
-    } catch (error) {
-      logger.error('Failed to read upload result file', { error });
-      return null;
-    }
-  }
-
-  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;
+      const result = JSON.parse(data);
+      logger.debug('Successfully read upload result', { shareLink: result.shareLink });
+      return result;
     } catch (error) {
+      logger.error('Failed to read upload result file', { error: error.message, stack: error.stack });
       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() {
@@ -128,11 +116,19 @@ class ProcessManager {
   cleanup(options = {}) {
     const { preserveResult = false } = options;
     try {
-      if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
-      if (fs.existsSync(STATUS_FILE)) fs.unlinkSync(STATUS_FILE);
-      if (!preserveResult && fs.existsSync(RESULT_FILE)) fs.unlinkSync(RESULT_FILE);
+      logger.debug('Cleanup called', { preserveResult, resultFileExists: fs.existsSync(RESULT_FILE) });
+      if (fs.existsSync(STATUS_FILE)) {
+        fs.unlinkSync(STATUS_FILE);
+        logger.debug('Deleted STATUS file');
+      }
+      if (!preserveResult && fs.existsSync(RESULT_FILE)) {
+        fs.unlinkSync(RESULT_FILE);
+        logger.debug('Deleted RESULT file');
+      } else if (preserveResult && fs.existsSync(RESULT_FILE)) {
+        logger.debug('Preserved RESULT file');
+      }
     } catch (error) {
-      logger.error('Failed to cleanup process files', { error });
+      logger.error('Failed to cleanup process files', { error: error.message });
     }
   }
 
@@ -145,64 +141,50 @@ 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';
+      const pid = status.pid;
+      logger.info('Stopping background recording process', { pid, hasStoredPid: !!pid });
       
-      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 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 {
-            execSync(`taskkill /PID ${pid} /T`, { stdio: 'ignore', timeout: 5000 });
-            logger.info('Sent graceful shutdown signal to process');
+            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) {
-            // If graceful shutdown fails or times out, force kill
-            logger.warn('Graceful shutdown failed, forcing termination');
-            execSync(`taskkill /PID ${pid} /F /T`, { stdio: 'ignore' });
+            logger.warn('Failed to kill process with taskkill', { error: error.message });
           }
-        } 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();
-      
-      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');
-        if (!isWindows) {
+        } else {
           try {
-            process.kill(pid, 'SIGKILL');
+            process.kill(pid, 'SIGINT');
           } catch (error) {
-            logger.warn('Failed to send SIGKILL', { error: error.message });
+            logger.warn('Failed to send SIGINT', { error: error.message });
           }
-          await new Promise(resolve => setTimeout(resolve, 1000));
         }
       }
       
+      // Mark recording as stopped in status file immediately
+      this.writeStatus({
+        isRecording: false,
+        stoppedAt: Date.now(),
+        pid: pid
+      });
+      
       if (status) {
         logger.info('Recording stopped, returning status', { 
           outputPath: status.outputPath,
@@ -256,9 +238,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,
@@ -266,17 +245,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.33",
+  "version": "1.0.1-beta.35",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/index.js",
   "bin": {