dashcam 1.0.1-beta.28 → 1.0.1-beta.29

package/bin/dashcam.js

@@ -466,43 +466,58 @@ program
 
         console.log('Recording stopped successfully');
         
-        // Check if the result already has a shareLink (from signal handler upload)
-        if (result.shareLink) {
-          console.log('📹 Watch your recording:', result.shareLink);
+        // Wait for upload to complete (background process handles this)
+        logger.debug('Waiting for background upload to complete...');
+        console.log('⏳ Uploading recording...');
+        
+        // Wait up to 2 minutes for upload result to appear
+        const maxWaitForUpload = 120000; // 2 minutes
+        const startWaitForUpload = Date.now();
+        let uploadResult = null;
+        
+        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
+          uploadResult = processManager.readUploadResult();
+          if (!uploadResult) {
+            await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
+          }
+        }
+        
+        logger.debug('Upload result read attempt', { found: !!uploadResult, shareLink: uploadResult?.shareLink });
+        
+        if (uploadResult && uploadResult.shareLink) {
+          console.log('📹 Watch your recording:', uploadResult.shareLink);
+          // Clean up the result file now that we've read it
           processManager.cleanup();
           process.exit(0);
         }
         
-        // Otherwise, check if upload result file was written
-        const uploadResultFromFile = processManager.readUploadResult();
-        logger.debug('Upload result read attempt', { found: !!uploadResultFromFile, shareLink: uploadResultFromFile?.shareLink });
+        // 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));
         
-        if (uploadResultFromFile && uploadResultFromFile.shareLink) {
-          console.log('📹 Watch your recording:', uploadResultFromFile.shareLink);
-          processManager.cleanup();
+        if (!filesExist) {
+          console.log('✅ Recording uploaded by background process');
+          logger.info('Files were cleaned up by background process');
           process.exit(0);
         }
         
-        // No upload result found - need to upload ourselves
-        // This commonly happens on Windows where signal handlers work differently
-        logger.info('No upload result found, uploading now...');
+        // Always attempt to upload - let upload function find project if needed
         console.log('Uploading recording...');
-        
         try {
           const uploadResult = await upload(result.outputPath, {
             title: activeStatus?.options?.title,
             description: activeStatus?.options?.description,
-            project: activeStatus?.options?.project,
+            project: activeStatus?.options?.project, // May be undefined, that's ok
             duration: result.duration,
             clientStartDate: result.clientStartDate,
             apps: result.apps,
-            logs: result.logs,
+            icons: result.icons,
             gifPath: result.gifPath,
             snapshotPath: result.snapshotPath
           });
           
           console.log('📹 Watch your recording:', uploadResult.shareLink);
-          processManager.cleanup();
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           console.log('Recording saved locally:', result.outputPath);

package/lib/processManager.js

@@ -171,14 +171,9 @@ class ProcessManager {
         this.cleanup({ preserveResult: true });
         return result;
       } else {
-        // Different process - send signal to stop it
+        // Different process - send signal (for backward compatibility if needed)
         logger.info('Stopping active recording process', { pid });
-        
-        try {
-          process.kill(pid, 'SIGINT');
-        } catch (error) {
-          logger.warn('Failed to send SIGINT, process may have already exited', { error: error.message });
-        }
+        process.kill(pid, 'SIGINT');
         
         // Wait for the process to actually finish
         const maxWaitTime = 120000; // 2 minutes max
@@ -190,55 +185,12 @@ class ProcessManager {
         
         if (this.isProcessRunning(pid)) {
           logger.warn('Process did not stop within timeout, forcing termination');
-          try {
-            process.kill(pid, 'SIGKILL');
-          } catch (error) {
-            logger.warn('Failed to send SIGKILL', { error: error.message });
-          }
+          process.kill(pid, 'SIGKILL');
           await new Promise(resolve => setTimeout(resolve, 1000));
         }
         
-        // Wait a bit for upload result file to be written by the signal handler
-        logger.debug('Waiting for upload result file...');
-        const maxWaitForUpload = 10000; // 10 seconds
-        const startWaitForUpload = Date.now();
-        let uploadResult = null;
-        
-        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
-          uploadResult = this.readUploadResult();
-          if (!uploadResult) {
-            await new Promise(resolve => setTimeout(resolve, 500));
-          }
-        }
-        
-        // If upload result exists, the signal handler did the upload
-        if (uploadResult) {
-          logger.info('Upload completed by recording process');
-          if (status) {
-            const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
-            const result = {
-              outputPath: status.outputPath,
-              gifPath: `${basePath}.gif`,
-              snapshotPath: `${basePath}.png`,
-              duration: Date.now() - status.startTime,
-              clientStartDate: status.startTime,
-              apps: [],
-              logs: [],
-              shareLink: uploadResult.shareLink,
-              replayId: uploadResult.replayId
-            };
-            
-            this.cleanup({ preserveResult: false }); // Clean up everything including result
-            return result;
-          }
-        }
-        
-        // If no upload result, we need to handle it ourselves
-        // This can happen on Windows where signal handlers don't work the same way
-        logger.warn('No upload result found, handling upload in stop command');
-        
         if (status) {
-          logger.info('Reconstructing result from status', { 
+          logger.info('Recording stopped, returning status', { 
             outputPath: status.outputPath,
             duration: Date.now() - status.startTime
           });
@@ -254,14 +206,7 @@ class ProcessManager {
             logs: []
           };
           
-          // Don't cleanup yet - let the stop command handle upload
-          // Just update status to not recording
-          this.writeStatus({
-            isRecording: false,
-            completedTime: Date.now(),
-            pid: status.pid
-          });
-          
+          this.cleanup({ preserveResult: true });
           return result;
         } else {
           throw new Error('No status information available for active recording');

package/package.json

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