dashcam 1.0.1-beta.30 → 1.0.1-beta.32

package/bin/dashcam.js

@@ -136,55 +136,11 @@ async function recordingAction(options, command) {
       log('Use "dashcam status" to check progress');
       log('Use "dashcam stop" to stop recording and upload');
       
-      // Keep the process alive so recording continues
-      // Set up graceful shutdown handlers
-      const handleShutdown = async (signal) => {
-        log(`\nReceived ${signal}, stopping recording...`);
-        try {
-          const result = await processManager.stopActiveRecording();
-          
-          if (result) {
-            log('Recording stopped successfully');
-            log('Uploading recording...');
-            
-            try {
-              const uploadResult = await upload(result.outputPath, {
-                title: options.title || 'Dashcam Recording',
-                description: description,
-                project: options.project || options.k,
-                duration: result.duration,
-                clientStartDate: result.clientStartDate,
-                apps: result.apps,
-                icons: result.icons,
-                gifPath: result.gifPath,
-                snapshotPath: result.snapshotPath
-              });
-              
-              // Write upload result for stop command to read
-              processManager.writeUploadResult({
-                shareLink: uploadResult.shareLink,
-                replayId: uploadResult.replay?.id
-              });
-              
-              log('📹 Watch your recording:', uploadResult.shareLink);
-            } catch (uploadError) {
-              logError('Upload failed:', uploadError.message);
-              log('Recording saved locally:', result.outputPath);
-            }
-          }
-          
-          process.exit(0);
-        } catch (error) {
-          logError('Failed to stop recording:', error.message);
-          process.exit(1);
-        }
-      };
-      
-      process.on('SIGINT', handleShutdown);
-      process.on('SIGTERM', handleShutdown);
-      
-      // Keep process alive indefinitely until stopped
-      await new Promise(() => {}); // Wait forever
+      // Close stdout/stderr and exit immediately to prevent blocking
+      // when called from automation scripts with piped output
+      process.stdout.end();
+      process.stderr.end();
+      process.exit(0);
       
     } catch (error) {
       logError('Failed to start recording:', error.message);

package/lib/processManager.js

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
 
 // Use a fixed directory in the user's home directory for cross-process communication
@@ -151,91 +153,69 @@ class ProcessManager {
         return false;
       }
       
-      // Check if this is the same process (direct recording)
-      if (pid === process.pid) {
-        logger.info('Stopping recording in current process');
-        
-        // Import recorder module
-        const { stopRecording: stopRecorderRecording } = await import('./recorder.js');
-        
-        // Stop recording directly
-        const result = await stopRecorderRecording();
-        
-        // Update status to indicate recording stopped
-        this.writeStatus({
-          isRecording: false,
-          completedTime: Date.now(),
-          pid: process.pid
-        });
-        
-        this.cleanup({ preserveResult: true });
-        return result;
+      logger.info('Stopping detached background process', { pid });
+      
+      // Send signal to background process
+      const isWindows = process.platform === 'win32';
+      
+      if (isWindows) {
+        logger.info('Windows detected, using taskkill to stop process');
+        try {
+          // Use taskkill to forcefully stop the process tree on Windows
+          const { execSync } = await import('child_process');
+          execSync(`taskkill /PID ${pid} /F /T`, { stdio: 'ignore' });
+        } catch (error) {
+          logger.warn('Failed to kill process with taskkill', { error: error.message });
+        }
       } else {
-        // Different process - need to stop it
-        logger.info('Stopping active recording process', { pid });
-        
-        // On Windows, signals don't work the same way, so we need to forcefully terminate
-        const isWindows = process.platform === 'win32';
-        
-        if (isWindows) {
-          logger.info('Windows detected, using taskkill to stop process');
-          try {
-            // Use taskkill to forcefully stop the process tree on Windows
-            const { execSync } = await import('child_process');
-            execSync(`taskkill /PID ${pid} /F /T`, { stdio: 'ignore' });
-          } 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) {
           try {
-            process.kill(pid, 'SIGINT');
+            process.kill(pid, 'SIGKILL');
           } catch (error) {
-            logger.warn('Failed to send SIGINT', { error: error.message });
+            logger.warn('Failed to send SIGKILL', { error: error.message });
           }
+          await new Promise(resolve => setTimeout(resolve, 1000));
         }
+      }
+      
+      if (status) {
+        logger.info('Recording stopped, returning status', { 
+          outputPath: status.outputPath,
+          duration: Date.now() - status.startTime
+        });
         
-        // 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) {
-            try {
-              process.kill(pid, 'SIGKILL');
-            } catch (error) {
-              logger.warn('Failed to send SIGKILL', { error: error.message });
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000));
-          }
-        }
+        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: []
+        };
         
-        if (status) {
-          logger.info('Recording stopped, returning status', { 
-            outputPath: status.outputPath,
-            duration: Date.now() - status.startTime
-          });
-          
-          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: []
-          };
-          
-          this.cleanup({ preserveResult: true });
-          return result;
-        } else {
-          throw new Error('No status information available for active recording');
-        }
+        this.cleanup({ preserveResult: true });
+        return result;
+      } else {
+        throw new Error('No status information available for active recording');
       }
     } catch (error) {
       logger.error('Failed to stop recording', { error });
@@ -251,41 +231,56 @@ class ProcessManager {
       throw new Error('Recording already in progress');
     }
 
-    // Import recorder module
-    const { startRecording: startRecorderRecording } = await import('./recorder.js');
+    logger.info('Starting recording in detached background process');
     
-    logger.info('Starting recording directly');
+    // Get the path to the background script
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const backgroundScript = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
     
-    // Start recording using the recorder module
-    const recordingOptions = {
-      fps: parseInt(options.fps) || 10,
-      includeAudio: options.audio || false,
-      customOutputPath: options.output || null
+    // On Windows, we need to ensure stdio is completely detached
+    const isWindows = process.platform === 'win32';
+    const spawnOptions = {
+      detached: true,
+      stdio: 'ignore'
     };
+    
+    // On Windows, also create a new process group to fully detach
+    if (isWindows) {
+      spawnOptions.windowsHide = true;
+    }
+    
+    // Spawn a detached background process
+    const child = spawn(process.execPath, [backgroundScript, JSON.stringify(options)], spawnOptions);
+    
+    // Unref so the parent process can exit
+    child.unref();
+    
+    const pid = child.pid;
+    
+    // Write PID file immediately so other commands can find the recording process
+    this.writePid(pid);
 
-    const result = await startRecorderRecording(recordingOptions);
-
-    // Write status to track the recording
-    this.writeStatus({
-      isRecording: true,
-      startTime: result.startTime,
-      options,
-      pid: process.pid,
-      outputPath: result.outputPath
-    });
-
-    // Write PID file so other commands can find the recording process
-    this.writePid(process.pid);
-
-    logger.info('Recording started successfully', { 
-      pid: process.pid,
-      outputPath: result.outputPath
+    logger.info('Background process spawned successfully', { 
+      pid,
+      backgroundScript,
+      platform: process.platform
     });
+    
+    // Wait a moment for the background process to write its status
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Read the status to get output path and start time
+    const status = this.readStatus();
+    
+    if (!status) {
+      throw new Error('Background process failed to write status');
+    }
 
     return {
-      pid: process.pid,
-      outputPath: result.outputPath,
-      startTime: result.startTime
+      pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime
     };
   }
 

package/package.json

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