dashcam 1.0.1-beta.34 → 1.0.1-beta.35

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;
@@ -83,45 +90,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,10 +117,6 @@ 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');
@@ -161,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,
@@ -272,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,
@@ -282,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.34",
+  "version": "1.0.1-beta.35",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/index.js",
   "bin": {