dashcam 1.3.12-beta → 1.3.14-beta

package/bin/dashcam.js

@@ -404,55 +404,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 +506,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

@@ -10,7 +10,6 @@ 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');
-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');
 
@@ -52,6 +51,22 @@ class ProcessManager {
     }
   }
 
+  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 +97,6 @@ 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 {
@@ -111,16 +108,17 @@ class ProcessManager {
   }
 
   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
-      this.cleanup({ preserveResult: true });
+    if (!status || !status.pid || !this.isProcessRunning(status.pid)) {
+      // Mark as completed if process is dead but status exists
+      if (status && status.isRecording) {
+        this.markStatusCompleted({ reason: 'process_not_running' });
+      }
       return false;
     }
     
-    return status && status.isRecording;
+    return status.isRecording;
   }
 
   getActiveStatus() {
@@ -131,8 +129,7 @@ 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);
+      // 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 });
@@ -149,16 +146,16 @@ class ProcessManager {
     
     try {
       const status = this.readStatus();
-      const pid = this.readPid();
       
       if (!status || !status.isRecording) {
         logger.warn('No active recording found');
         return false;
       }
       
+      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;
       }
       
@@ -193,6 +190,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 {
@@ -312,11 +315,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.12-beta",
+  "version": "1.3.14-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {