dashcam 1.0.1-beta.27 → 1.0.1-beta.28

package/bin/dashcam.js

@@ -466,58 +466,43 @@ program
 
         console.log('Recording stopped successfully');
         
-        // 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
+        // Check if the result already has a shareLink (from signal handler upload)
+        if (result.shareLink) {
+          console.log('📹 Watch your recording:', result.shareLink);
           processManager.cleanup();
           process.exit(0);
         }
         
-        // 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));
+        // Otherwise, check if upload result file was written
+        const uploadResultFromFile = processManager.readUploadResult();
+        logger.debug('Upload result read attempt', { found: !!uploadResultFromFile, shareLink: uploadResultFromFile?.shareLink });
         
-        if (!filesExist) {
-          console.log('✅ Recording uploaded by background process');
-          logger.info('Files were cleaned up by background process');
+        if (uploadResultFromFile && uploadResultFromFile.shareLink) {
+          console.log('📹 Watch your recording:', uploadResultFromFile.shareLink);
+          processManager.cleanup();
           process.exit(0);
         }
         
-        // Always attempt to upload - let upload function find project if needed
+        // 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...');
         console.log('Uploading recording...');
+        
         try {
           const uploadResult = await upload(result.outputPath, {
             title: activeStatus?.options?.title,
             description: activeStatus?.options?.description,
-            project: activeStatus?.options?.project, // May be undefined, that's ok
+            project: activeStatus?.options?.project,
             duration: result.duration,
             clientStartDate: result.clientStartDate,
             apps: result.apps,
-            icons: result.icons,
+            logs: result.logs,
             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,9 +171,14 @@ class ProcessManager {
         this.cleanup({ preserveResult: true });
         return result;
       } else {
-        // Different process - send signal (for backward compatibility if needed)
+        // Different process - send signal to stop it
         logger.info('Stopping active recording process', { pid });
-        process.kill(pid, 'SIGINT');
+        
+        try {
+          process.kill(pid, 'SIGINT');
+        } catch (error) {
+          logger.warn('Failed to send SIGINT, process may have already exited', { error: error.message });
+        }
         
         // Wait for the process to actually finish
         const maxWaitTime = 120000; // 2 minutes max
@@ -185,12 +190,55 @@ class ProcessManager {
         
         if (this.isProcessRunning(pid)) {
           logger.warn('Process did not stop within timeout, forcing termination');
-          process.kill(pid, 'SIGKILL');
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch (error) {
+            logger.warn('Failed to send SIGKILL', { error: error.message });
+          }
           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('Recording stopped, returning status', { 
+          logger.info('Reconstructing result from status', { 
             outputPath: status.outputPath,
             duration: Date.now() - status.startTime
           });
@@ -206,7 +254,14 @@ class ProcessManager {
             logs: []
           };
           
-          this.cleanup({ preserveResult: true });
+          // 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
+          });
+          
           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.27",
+  "version": "1.0.1-beta.28",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/index.js",
   "bin": {