dashcam 1.3.13-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);
       }
 
@@ -404,55 +435,94 @@ program
       const logFile = path.join(process.cwd(), '.dashcam', 'recording.log');
 
       console.log('Stopping recording...');
+      logger.debug('Active status before stop:', activeStatus);
       
       try {
+        logger.debug('Calling stopActiveRecording...');
         const result = await processManager.stopActiveRecording();
         
         if (!result) {
           console.log('Failed to stop recording');
+          logger.error('stopActiveRecording returned null/false');
           process.exit(1);
         }
 
         console.log('Recording stopped successfully');
+        logger.debug('Stop result:', result);
         
         // Wait for upload to complete (background process handles this)
         logger.debug('Waiting for background upload to complete...');
-        console.log('Uploading recording...');
+        console.log('Checking if background process uploaded...');
         
         // Wait up to 2 minutes for upload result to appear
         const maxWaitForUpload = 120000; // 2 minutes
         const startWaitForUpload = Date.now();
         let uploadResult = null;
+        let checkCount = 0;
         
         while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
           uploadResult = processManager.readUploadResult();
+          checkCount++;
+          
           if (!uploadResult) {
+            // Log every 10 seconds to show progress
+            if (checkCount % 10 === 0) {
+              const elapsed = Math.round((Date.now() - startWaitForUpload) / 1000);
+              logger.debug(`Still waiting for background upload... (${elapsed}s elapsed)`);
+              console.log(`Waiting for background upload... (${elapsed}s)`);
+            }
             await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
           }
         }
         
-        logger.debug('Upload result read attempt', { found: !!uploadResult, shareLink: uploadResult?.shareLink });
+        logger.debug('Upload result read attempt', { 
+          found: !!uploadResult, 
+          shareLink: uploadResult?.shareLink,
+          checksPerformed: checkCount,
+          timeElapsed: Math.round((Date.now() - startWaitForUpload) / 1000) + 's'
+        });
         
         if (uploadResult && uploadResult.shareLink) {
           console.log('Watch your recording:', uploadResult.shareLink);
+          logger.info('Background process upload succeeded');
           // Clean up the result file now that we've read it
           processManager.cleanup();
           process.exit(0);
         }
         
+        logger.debug('No upload result from background process, checking files...');
+        
         // 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));
+        const videoExists = fs.existsSync(result.outputPath);
+        const gifExists = !result.gifPath || fs.existsSync(result.gifPath);
+        const snapshotExists = !result.snapshotPath || fs.existsSync(result.snapshotPath);
+        
+        logger.debug('File existence check:', {
+          video: videoExists,
+          gif: gifExists,
+          snapshot: snapshotExists,
+          outputPath: result.outputPath,
+          gifPath: result.gifPath,
+          snapshotPath: result.snapshotPath
+        });
+        
+        const filesExist = videoExists && gifExists && snapshotExists;
         
         if (!filesExist) {
-          console.log('Recording uploaded by background process');
-          logger.info('Files were cleaned up by background process');
+          console.log('Recording appears to be uploaded by background process (files deleted)');
+          logger.info('Files were cleaned up by background process, assuming upload succeeded');
           process.exit(0);
         }
         
         // Always attempt to upload - let upload function find project if needed
-        console.log('Uploading recording...');
+        console.log('No upload result found, uploading from foreground process...');
+        logger.debug('Starting foreground upload with metadata:', {
+          title: activeStatus?.options?.title,
+          project: activeStatus?.options?.project,
+          duration: result.duration,
+          outputPath: result.outputPath
+        });
+        
         try {
           const uploadResult = await upload(result.outputPath, {
             title: activeStatus?.options?.title,
@@ -467,12 +537,23 @@ program
           });
           
           console.log('Watch your recording:', uploadResult.shareLink);
+          logger.info('Foreground upload succeeded');
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
+          logger.error('Upload error details:', {
+            message: uploadError.message,
+            stack: uploadError.stack,
+            code: uploadError.code,
+            statusCode: uploadError.response?.statusCode
+          });
           console.log('Recording saved locally:', result.outputPath);
         }
       } catch (error) {
         console.error('Failed to stop recording:', error.message);
+        logger.error('Stop recording error details:', {
+          message: error.message,
+          stack: error.stack
+        });
         process.exit(1);
       }
       

package/lib/processManager.js

@@ -30,27 +30,86 @@ 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;
     }
   }
 
+  markStatusCompleted(completionData = {}) {
+    try {
+      const status = this.readStatus();
+      if (status) {
+        fs.writeFileSync(STATUS_FILE, JSON.stringify({
+          ...status,
+          isRecording: false,
+          completedAt: Date.now(),
+          ...completionData
+        }, null, 2));
+      }
+    } catch (error) {
+      logger.error('Failed to mark status as completed', { error });
+    }
+  }
+
   writeUploadResult(result) {
     try {
       logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
@@ -82,24 +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)) {
-      // Clean up but preserve upload result in case the background process just finished uploading
-      this.cleanup({ preserveResult: true });
+    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.isRecording) {
+        this.markStatusCompleted({ reason: 'process_not_running' });
+      }
+      return false;
+    }
+    
+    logger.debug('Recording active status', {
+      isRecording: status.isRecording,
+      pid: status.pid
+    });
+    
     return status.isRecording;
   }
 
@@ -111,7 +223,7 @@ class ProcessManager {
   cleanup(options = {}) {
     const { preserveResult = false } = options;
     try {
-      if (fs.existsSync(STATUS_FILE)) fs.unlinkSync(STATUS_FILE);
+      // Only delete result file, keep status file for history
       if (!preserveResult && fs.existsSync(RESULT_FILE)) fs.unlinkSync(RESULT_FILE);
     } catch (error) {
       logger.error('Failed to cleanup process files', { error });
@@ -137,7 +249,7 @@ class ProcessManager {
       const pid = status.pid;
       if (!pid || !this.isProcessRunning(pid)) {
         logger.warn('Background process not running');
-        this.cleanup({ preserveResult: true });
+        this.markStatusCompleted({ reason: 'process_already_stopped' });
         return false;
       }
       
@@ -172,6 +284,12 @@ class ProcessManager {
       
       logger.info('Background process stopped');
       
+      // Mark status as completed
+      this.markStatusCompleted({ 
+        reason: 'stopped_by_user',
+        duration: Date.now() - status.startTime
+      });
+      
       // Return a minimal result indicating success
       // The upload will be handled by the stop command checking the result file
       return {
@@ -291,11 +409,8 @@ class ProcessManager {
         logger.info('Recording stopped successfully during graceful exit');
       } catch (error) {
         logger.error('Failed to stop recording during graceful exit', { error });
-        this.cleanup(); // Fallback cleanup
+        this.markStatusCompleted({ reason: 'graceful_exit_error' });
       }
-    } else {
-      // Just cleanup if no recording is active
-      this.cleanup();
     }
     
     process.exit(0);

package/lib/uploader.js

@@ -110,6 +110,11 @@ class Uploader {
               total: progress.total,
               speedMBps: speedMBps.toFixed(2)
             });
+            
+            // Also output to console for user feedback
+            if (fileType === 'video') {
+              console.log(`Uploading video: ${percent}%`);
+            }
           }
           
           // Call progress callback if registered
@@ -125,6 +130,7 @@ class Uploader {
       const uploadDuration = (Date.now() - upload.startTime) / 1000;
       
       if (extension !== 'png') {
+        console.log(`Uploaded ${fileType} successfully (${uploadDuration.toFixed(1)}s)`);
         logger.info(`Successfully uploaded ${fileType}`, {
           key: result.Key,
           location: result.Location,
@@ -143,10 +149,14 @@ class Uploader {
       logExit();
       return result;
     } catch (error) {
+      console.error(`Failed to upload ${fileType}: ${error.message}`);
       logger.error('Upload error:', { 
         fileType,
         file: path.basename(file),
         error: error.message,
+        code: error.code,
+        statusCode: error.$metadata?.httpStatusCode,
+        requestId: error.$metadata?.requestId,
         stack: error.stack 
       });
       
@@ -254,6 +264,7 @@ export async function upload(filePath, metadata = {}) {
 
   logger.verbose('Creating replay with config', replayConfig);
 
+  console.log('Creating replay on server...');
   logger.info('Creating replay', replayConfig);
 
   // Create the replay first
@@ -261,6 +272,7 @@ export async function upload(filePath, metadata = {}) {
   
   let newReplay;
   try {
+    logger.debug('Sending replay creation request...');
     newReplay = await got.post('https://testdriver-api.onrender.com/api/v1/replay', {
       headers: {
         Authorization: `Bearer ${token}`
@@ -269,16 +281,19 @@ export async function upload(filePath, metadata = {}) {
       timeout: 30000
     }).json();
 
+    console.log('Replay created successfully');
     logger.info('Replay created successfully', {
       replayId: newReplay.replay.id,
       shareKey: newReplay.replay.shareKey,
       shareLink: newReplay.replay.shareLink
     });
   } catch (error) {
+    console.error('Failed to create replay on server');
     logger.error('Failed to create replay', {
       status: error.response?.statusCode,
       statusText: error.response?.statusMessage,
       body: error.response?.body,
+      message: error.message,
       replayConfig: replayConfig
     });
     throw error;
@@ -310,8 +325,10 @@ export async function upload(filePath, metadata = {}) {
   }
 
   logger.verbose('Getting STS credentials for replay', { replayId: newReplay.replay.id });
+  console.log('Getting upload credentials...');
   const sts = await auth.getStsCredentials(replayData);
 
+  console.log('Starting file uploads...');
   logger.verbose('STS credentials received', {
     hasVideo: !!sts.video,
     hasImage: !!sts.image,
@@ -342,6 +359,7 @@ export async function upload(filePath, metadata = {}) {
   }
 
   logger.info('Starting asset uploads', { totalUploads: promises.length });
+  console.log(`Uploading ${promises.length} file(s)...`);
   
   // Process and upload logs if available
   if (metadata.logs && metadata.logs.length > 0) {
@@ -420,6 +438,8 @@ export async function upload(filePath, metadata = {}) {
     });
   }
 
+  logger.debug('Waiting for all uploads to complete...');
+  console.log('Finalizing uploads...');
   await Promise.all(promises);
 
   // Clean up uploaded files after all uploads complete successfully
@@ -436,13 +456,27 @@ export async function upload(filePath, metadata = {}) {
 
   // Publish the replay (like the desktop app does)
   logger.debug('Publishing replay...');
-  await got.post('https://testdriver-api.onrender.com/api/v1/replay/publish', {
-    headers: {
-      Authorization: `Bearer ${token}`
-    },
-    json: { id: newReplay.replay.id },
-    timeout: 30000
-  }).json();
+  console.log('Publishing replay...');
+  
+  try {
+    await got.post('https://testdriver-api.onrender.com/api/v1/replay/publish', {
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      json: { id: newReplay.replay.id },
+      timeout: 30000
+    }).json();
+    
+    console.log('Replay published successfully');
+  } catch (error) {
+    console.error('Failed to publish replay:', error.message);
+    logger.error('Publish error:', {
+      message: error.message,
+      statusCode: error.response?.statusCode,
+      body: error.response?.body
+    });
+    throw error;
+  }
 
   logger.info('Upload process completed successfully', {
     replayId: newReplay.replay.id,

package/package.json

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