dashcam 1.3.14-beta → 1.3.16-beta

package/bin/dashcam-background.js

@@ -11,8 +11,8 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 
-// Get process directory for status files
-const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
+// Get process directory for status files (system temp for cross-session access)
+const PROCESS_DIR = path.join(os.tmpdir(), 'dashcam-cli');
 const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
 const RESULT_FILE = path.join(PROCESS_DIR, 'upload-result.json');
 
@@ -28,6 +28,13 @@ const options = JSON.parse(optionsJson);
 // Enable verbose logging in background
 setVerbose(true);
 
+console.log('[Background] Process started', { 
+  pid: process.pid,
+  platform: process.platform,
+  processDir: PROCESS_DIR,
+  statusFile: STATUS_FILE
+});
+
 logger.info('Background recording process started', { 
   pid: process.pid,
   options 
@@ -36,13 +43,43 @@ 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
+    };
+    
+    console.log('[Background] 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)) {
+      console.log('[Background] Status file written and verified:', STATUS_FILE);
+      
+      // Read it back to verify content
+      const writtenContent = fs.readFileSync(STATUS_FILE, 'utf8');
+      console.log('[Background] Status file content verification:', { 
+        contentLength: writtenContent.length,
+        parseable: true 
+      });
+    } else {
+      console.error('[Background] Status file does not exist after write!', STATUS_FILE);
+      logger.error('Status file does not exist after write!', { statusFile: STATUS_FILE });
+    }
   } catch (error) {
-    logger.error('Failed to write status file', { error });
+    console.error('[Background] Failed to write status file:', error.message);
+    logger.error('Failed to write status file in background process', { 
+      error: error.message,
+      stack: error.stack,
+      statusFile: STATUS_FILE
+    });
   }
 }
 
@@ -74,9 +111,12 @@ async function runBackgroundRecording() {
     };
 
     logger.info('Starting recording with options', { recordingOptions });
+    console.log('[Background] Starting recording with options:', recordingOptions);
 
     recordingResult = await startRecording(recordingOptions);
 
+    console.log('[Background] Recording started, writing status file...');
+    
     // Write status to track the recording
     writeStatus({
       isRecording: true,
@@ -90,6 +130,12 @@ async function runBackgroundRecording() {
       outputPath: recordingResult.outputPath,
       startTime: recordingResult.startTime 
     });
+    
+    console.log('[Background] Recording started successfully', {
+      outputPath: recordingResult.outputPath,
+      startTime: recordingResult.startTime,
+      pid: process.pid
+    });
 
     // Set up signal handlers for graceful shutdown
     const handleShutdown = async (signal) => {

package/bin/dashcam.js

@@ -395,8 +395,40 @@ 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('path').join(require('os').tmpdir(), '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').tmpdir(), 'dashcam-cli', 'status.json'),
+          statusFileExists: require('fs').existsSync(require('path').join(require('os').tmpdir(), 'dashcam-cli', 'status.json'))
+        });
+        
+        // Try to read and display status file for debugging
+        try {
+          const statusPath = require('path').join(require('os').tmpdir(), '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');
+            console.log('Expected status file location:', statusPath);
+          }
+        } catch (err) {
+          logger.error('Failed to read status file for debugging', { error: err.message });
+        }
+        
         process.exit(0);
       }
 

package/lib/processManager.js

@@ -8,8 +8,8 @@ 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');
+// Use system temp directory for cross-session communication
+const PROCESS_DIR = path.join(os.tmpdir(), 'dashcam-cli');
 const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
 const RESULT_FILE = path.join(PROCESS_DIR, 'upload-result.json');
 
@@ -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.16-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {