dashcam 1.3.14-beta → 1.3.15-beta

package/bin/dashcam-background.js

@@ -36,13 +36,41 @@ logger.info('Background recording process started', {
 // Write status file
 function writeStatus(status) {
   try {
-    fs.writeFileSync(STATUS_FILE, JSON.stringify({
+    const statusData = {
       ...status,
       timestamp: Date.now(),
-      pid: process.pid
-    }, null, 2));
+      pid: process.pid,
+      platform: process.platform
+    };
+    
+    logger.debug('Background process writing status file', {
+      statusFile: STATUS_FILE,
+      pid: statusData.pid,
+      isRecording: statusData.isRecording,
+      platform: statusData.platform
+    });
+    
+    fs.writeFileSync(STATUS_FILE, JSON.stringify(statusData, null, 2));
+    
+    // Verify it was written
+    if (fs.existsSync(STATUS_FILE)) {
+      logger.debug('Status file written and verified', { statusFile: STATUS_FILE });
+      
+      // Read it back to verify content
+      const writtenContent = fs.readFileSync(STATUS_FILE, 'utf8');
+      logger.debug('Status file content verification', { 
+        contentLength: writtenContent.length,
+        parseable: true 
+      });
+    } else {
+      logger.error('Status file does not exist after write!', { statusFile: STATUS_FILE });
+    }
   } catch (error) {
-    logger.error('Failed to write status file', { error });
+    logger.error('Failed to write status file in background process', { 
+      error: error.message,
+      stack: error.stack,
+      statusFile: STATUS_FILE
+    });
   }
 }
 

package/bin/dashcam.js

@@ -395,8 +395,39 @@ program
       // Enable verbose logging for stop command
       setVerbose(true);
       
-      if (!processManager.isRecordingActive()) {
+      logger.debug('Stop command invoked', {
+        platform: process.platform,
+        cwd: process.cwd(),
+        pid: process.pid,
+        processDir: require('os').homedir() + '/.dashcam-cli'
+      });
+      
+      const isActive = processManager.isRecordingActive();
+      logger.debug('Recording active check result', { isActive });
+      
+      if (!isActive) {
         console.log('No active recording to stop');
+        logger.warn('Stop command called but no active recording found', {
+          platform: process.platform,
+          statusFile: require('path').join(require('os').homedir(), '.dashcam-cli', 'status.json'),
+          statusFileExists: require('fs').existsSync(require('path').join(require('os').homedir(), '.dashcam-cli', 'status.json'))
+        });
+        
+        // Try to read and display status file for debugging
+        try {
+          const statusPath = require('path').join(require('os').homedir(), '.dashcam-cli', 'status.json');
+          if (require('fs').existsSync(statusPath)) {
+            const statusContent = require('fs').readFileSync(statusPath, 'utf8');
+            logger.debug('Status file contents', { content: statusContent });
+            console.log('Status file exists but recording not detected as active');
+            console.log('Status file location:', statusPath);
+          } else {
+            console.log('Status file does not exist');
+          }
+        } catch (err) {
+          logger.error('Failed to read status file for debugging', { error: err.message });
+        }
+        
         process.exit(0);
       }
 

package/lib/processManager.js

@@ -30,23 +30,66 @@ class ProcessManager {
 
   writeStatus(status) {
     try {
-      fs.writeFileSync(STATUS_FILE, JSON.stringify({
+      const statusData = {
         ...status,
         timestamp: Date.now(),
         pid: process.pid
-      }, null, 2));
+      };
+      
+      logger.debug('Writing status file', {
+        statusFile: STATUS_FILE,
+        pid: statusData.pid,
+        isRecording: statusData.isRecording,
+        platform: process.platform
+      });
+      
+      fs.writeFileSync(STATUS_FILE, JSON.stringify(statusData, null, 2));
+      
+      // Verify it was written
+      if (fs.existsSync(STATUS_FILE)) {
+        logger.debug('Status file written successfully');
+      } else {
+        logger.error('Status file does not exist after write!');
+      }
     } catch (error) {
-      logger.error('Failed to write status file', { error });
+      logger.error('Failed to write status file', { 
+        error: error.message,
+        stack: error.stack,
+        statusFile: STATUS_FILE
+      });
     }
   }
 
   readStatus() {
     try {
-      if (!fs.existsSync(STATUS_FILE)) return null;
+      logger.debug('Reading status file', { 
+        statusFile: STATUS_FILE,
+        exists: fs.existsSync(STATUS_FILE)
+      });
+      
+      if (!fs.existsSync(STATUS_FILE)) {
+        logger.debug('Status file does not exist');
+        return null;
+      }
+      
       const data = fs.readFileSync(STATUS_FILE, 'utf8');
-      return JSON.parse(data);
+      const status = JSON.parse(data);
+      
+      logger.debug('Status file read successfully', {
+        pid: status.pid,
+        isRecording: status.isRecording,
+        timestamp: status.timestamp,
+        startTime: status.startTime,
+        outputPath: status.outputPath
+      });
+      
+      return status;
     } catch (error) {
-      logger.error('Failed to read status file', { error });
+      logger.error('Failed to read status file', { 
+        error: error.message,
+        stack: error.stack,
+        statusFile: STATUS_FILE
+      });
       return null;
     }
   }
@@ -98,26 +141,77 @@ class ProcessManager {
   }
 
   isProcessRunning(pid) {
-    if (!pid) return false;
+    if (!pid) {
+      logger.debug('isProcessRunning: no PID provided');
+      return false;
+    }
+    
     try {
       process.kill(pid, 0); // Signal 0 just checks if process exists
+      logger.debug('Process is running', { pid });
       return true;
     } catch (error) {
+      logger.debug('Process is not running', { 
+        pid, 
+        error: error.code,
+        platform: process.platform
+      });
       return false;
     }
   }
 
   isRecordingActive() {
+    logger.debug('Checking if recording is active...', {
+      statusFile: STATUS_FILE,
+      processDir: PROCESS_DIR,
+      platform: process.platform
+    });
+    
     const status = this.readStatus();
     
-    if (!status || !status.pid || !this.isProcessRunning(status.pid)) {
+    logger.debug('Status check result', {
+      hasStatus: !!status,
+      hasPid: !!(status && status.pid),
+      isRecording: status ? status.isRecording : null,
+      statusPid: status ? status.pid : null,
+      currentPid: process.pid
+    });
+    
+    if (!status) {
+      logger.debug('No status found - recording not active');
+      return false;
+    }
+    
+    if (!status.pid) {
+      logger.debug('Status has no PID - marking as completed');
+      this.markStatusCompleted({ reason: 'no_pid_in_status' });
+      return false;
+    }
+    
+    const processRunning = this.isProcessRunning(status.pid);
+    logger.debug('Process running check', {
+      pid: status.pid,
+      isRunning: processRunning
+    });
+    
+    if (!processRunning) {
+      logger.debug('Process not running - marking as completed', {
+        pid: status.pid,
+        wasRecording: status.isRecording
+      });
+      
       // Mark as completed if process is dead but status exists
-      if (status && status.isRecording) {
+      if (status.isRecording) {
         this.markStatusCompleted({ reason: 'process_not_running' });
       }
       return false;
     }
     
+    logger.debug('Recording active status', {
+      isRecording: status.isRecording,
+      pid: status.pid
+    });
+    
     return status.isRecording;
   }
 

package/package.json

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