dashcam 1.1.0-beta.5 → 1.3.0-beta

package/.github/workflows/publish.yml

@@ -8,7 +8,7 @@ on:
 jobs:
   publish-beta:
     runs-on: ubuntu-latest
-    
+
     steps:
       - uses: actions/checkout@v4
         with:
@@ -25,39 +25,25 @@ jobs:
           git config --global user.name "github-actions[bot]"
           git config --global user.email "github-actions[bot]@users.noreply.github.com"
 
-      - name: Check if this is a version bump commit
-        id: check_commit
-        run: |
-          if echo "${{ github.event.head_commit.message }}" | grep -q "chore: bump beta version"; then
-            echo "skip=true" >> $GITHUB_OUTPUT
-          else
-            echo "skip=false" >> $GITHUB_OUTPUT
-          fi
-
       - name: Install dependencies
-        if: steps.check_commit.outputs.skip != 'true'
         run: npm install
 
       - name: Commit dependency changes
-        if: steps.check_commit.outputs.skip != 'true'
         run: |
           git add package-lock.json
           git diff --staged --quiet || git commit -m "chore: update package-lock.json"
 
       - name: Bump version (prerelease beta)
-        if: steps.check_commit.outputs.skip != 'true'
         run: |
           npm version prerelease --preid=beta -m "chore: bump beta version to %s"
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Publish to npm under beta tag
-        if: steps.check_commit.outputs.skip != 'true'
         run: npm publish --tag beta
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Push version bump commit + tag
-        if: steps.check_commit.outputs.skip != 'true'
         run: |
           git push --follow-tags

package/bin/dashcam-background.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * Background recording process for dashcam CLI
+ * This script runs detached from the parent process to handle long-running recordings
+ */
+
+import { startRecording, stopRecording } from '../lib/recorder.js';
+import { upload } from '../lib/uploader.js';
+import { logger, setVerbose } from '../lib/logger.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Get process directory for status files
+const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
+const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
+const RESULT_FILE = path.join(PROCESS_DIR, 'upload-result.json');
+
+// Parse options from command line argument
+const optionsJson = process.argv[2];
+if (!optionsJson) {
+  console.error('No options provided to background process');
+  process.exit(1);
+}
+
+const options = JSON.parse(optionsJson);
+
+// Enable verbose logging in background
+setVerbose(true);
+
+logger.info('Background recording process started', { 
+  pid: process.pid,
+  options 
+});
+
+// Write status file
+function writeStatus(status) {
+  try {
+    fs.writeFileSync(STATUS_FILE, JSON.stringify({
+      ...status,
+      timestamp: Date.now(),
+      pid: process.pid
+    }, null, 2));
+  } catch (error) {
+    logger.error('Failed to write status file', { error });
+  }
+}
+
+// Write upload result file
+function writeUploadResult(result) {
+  try {
+    logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
+    fs.writeFileSync(RESULT_FILE, JSON.stringify({
+      ...result,
+      timestamp: Date.now()
+    }, null, 2));
+    logger.info('Successfully wrote upload result to file');
+  } catch (error) {
+    logger.error('Failed to write upload result file', { error });
+  }
+}
+
+// Main recording function
+async function runBackgroundRecording() {
+  let recordingResult = null;
+  let isShuttingDown = false;
+
+  try {
+    // Start the recording
+    const recordingOptions = {
+      fps: parseInt(options.fps) || 10,
+      includeAudio: options.audio || false,
+      customOutputPath: options.output || null
+    };
+
+    logger.info('Starting recording with options', { recordingOptions });
+
+    recordingResult = await startRecording(recordingOptions);
+
+    // Write status to track the recording
+    writeStatus({
+      isRecording: true,
+      startTime: recordingResult.startTime,
+      options,
+      pid: process.pid,
+      outputPath: recordingResult.outputPath
+    });
+
+    logger.info('Recording started successfully', { 
+      outputPath: recordingResult.outputPath,
+      startTime: recordingResult.startTime 
+    });
+
+    // Set up signal handlers for graceful shutdown
+    const handleShutdown = async (signal) => {
+      if (isShuttingDown) {
+        logger.info('Shutdown already in progress...');
+        return;
+      }
+      isShuttingDown = true;
+      
+      logger.info(`Received ${signal}, stopping background recording...`);
+      
+      try {
+        // Stop the recording
+        const stopResult = await stopRecording();
+        
+        if (stopResult) {
+          logger.info('Recording stopped successfully', { 
+            outputPath: stopResult.outputPath,
+            duration: stopResult.duration 
+          });
+          
+          // Upload the recording
+          logger.info('Starting upload...');
+          const uploadResult = await upload(stopResult.outputPath, {
+            title: options.title || 'Dashcam Recording',
+            description: options.description || 'Recorded with Dashcam CLI',
+            project: options.project || options.k,
+            duration: stopResult.duration,
+            clientStartDate: stopResult.clientStartDate,
+            apps: stopResult.apps,
+            logs: stopResult.logs,
+            gifPath: stopResult.gifPath,
+            snapshotPath: stopResult.snapshotPath
+          });
+          
+          logger.info('Upload complete', { shareLink: uploadResult.shareLink });
+          
+          // Write upload result for stop command to read
+          writeUploadResult({
+            shareLink: uploadResult.shareLink,
+            replayId: uploadResult.replay?.id
+          });
+        }
+        
+        // Update status to indicate recording stopped
+        writeStatus({
+          isRecording: false,
+          completedTime: Date.now(),
+          pid: process.pid
+        });
+        
+        logger.info('Background process exiting successfully');
+        process.exit(0);
+      } catch (error) {
+        logger.error('Error during shutdown:', error);
+        process.exit(1);
+      }
+    };
+    
+    process.on('SIGINT', () => handleShutdown('SIGINT'));
+    process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+    
+    // Keep the process alive
+    logger.info('Background recording is now running. Waiting for stop signal...');
+    await new Promise(() => {}); // Wait indefinitely for signals
+    
+  } catch (error) {
+    logger.error('Background recording failed:', error);
+    
+    // Update status to indicate failure
+    writeStatus({
+      isRecording: false,
+      error: error.message,
+      pid: process.pid
+    });
+    
+    process.exit(1);
+  }
+}
+
+// Run the background recording
+runBackgroundRecording().catch(error => {
+  logger.error('Fatal error in background process:', error);
+  process.exit(1);
+});

package/bin/dashcam.js

@@ -5,7 +5,7 @@ import { upload } from '../lib/uploader.js';
 import { logger, setVerbose } from '../lib/logger.js';
 import { APP } from '../lib/config.js';
 import { createPattern } from '../lib/tracking.js';
-import { startRecording, stopRecording, getRecordingStatus } from '../lib/recorder.js';
+import { processManager } from '../lib/processManager.js';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import path from 'path';
@@ -83,13 +83,14 @@ async function recordingAction(options, command) {
     const logError = (...args) => { if (!silent) console.error(...args); };
     
     // Check if recording is already active
-    const status = getRecordingStatus();
-    if (status.isRecording) {
-      const duration = (status.duration / 1000).toFixed(1);
+    if (processManager.isRecordingActive()) {
+      const status = processManager.getActiveStatus();
+      const duration = ((Date.now() - status.startTime) / 1000).toFixed(1);
       log('Recording already in progress');
       log(`Duration: ${duration} seconds`);
-      log('Stop the current recording before starting a new one');
-      process.exit(1);
+      log(`PID: ${status.pid}`);
+      log('Use "dashcam stop" to stop the recording');
+      process.exit(0);
     }
 
     // Check authentication
@@ -116,77 +117,26 @@ async function recordingAction(options, command) {
       process.exit(1);
     }
 
-    // Start recording
-    log('Starting recording...');
+    // Start recording in background mode
+    log('Starting recording in background...');
     
     try {
-      const recordingOptions = {
+      const result = await processManager.startRecording({
         fps: parseInt(options.fps) || 30,
-        includeAudio: options.audio || false,
-        customOutputPath: options.output
-      };
-      
-      const recordingMetadata = {
+        audio: options.audio,
+        output: options.output,
         title: options.title,
         description: description,
-        project: options.project || options.k
-      };
-
-      await startRecording(recordingOptions);
+        project: options.project || options.k // Support both -p and -k for project
+      });
 
-      log(`✅ Recording started successfully`);
+      log(`✅ Recording started successfully (PID: ${result.pid})`);
+      log(`Output: ${result.outputPath}`);
       log('');
-      log('Press Ctrl+C to stop recording and upload');
-      
-      // Set up graceful shutdown handlers
-      const handleShutdown = async (signal) => {
-        log('\nStopping recording...');
-        
-        try {
-          const result = await stopRecording();
-          
-          if (!result) {
-            log('Failed to stop recording');
-            process.exit(1);
-          }
-
-          log('Recording stopped successfully');
-          
-          // Upload the recording
-          log('Uploading recording...');
-          try {
-            const uploadResult = await upload(result.outputPath, {
-              title: recordingMetadata.title || 'Dashcam Recording',
-              description: recordingMetadata.description,
-              project: recordingMetadata.project,
-              duration: result.duration,
-              clientStartDate: result.clientStartDate,
-              apps: result.apps,
-              icons: result.icons,
-              logs: result.logs,
-              gifPath: result.gifPath,
-              snapshotPath: result.snapshotPath
-            });
-            
-            log('📹 Watch your recording:', uploadResult.shareLink);
-            process.exit(0);
-          } catch (uploadError) {
-            logError('Upload failed:', uploadError.message);
-            log('Recording saved locally:', result.outputPath);
-            process.exit(1);
-          }
-        } catch (error) {
-          logError('Failed to stop recording:', error.message);
-          process.exit(1);
-        }
-      };
-      
-      process.on('SIGINT', () => handleShutdown('SIGINT'));
-      process.on('SIGTERM', () => handleShutdown('SIGTERM'));
-      
-      // Keep process alive
-      await new Promise(() => {});
+      log('Use "dashcam status" to check progress');
+      log('Use "dashcam stop" to stop recording and upload');
       
+      process.exit(0);
     } catch (error) {
       logError('Failed to start recording:', error.message);
       process.exit(1);
@@ -198,6 +148,83 @@ async function recordingAction(options, command) {
   }
 }
 
+// 'create' command - creates a clip from current recording (like stop but with more options)
+program
+  .command('create')
+  .description('Create a clip and output the resulting url or markdown. Will launch desktop app for local editing before publishing.')
+  .option('-t, --title <string>', 'Title of the replay. Automatically generated if not supplied.')
+  .option('-d, --description [text]', 'Replay markdown body. This may also be piped in: `cat README.md | dashcam create`')
+  .option('--md', 'Returns code for a rich markdown image link.')
+  .option('-k, --project <project>', 'Project ID to publish to')
+  .action(async (options) => {
+    try {
+      // Check for piped input (description from stdin)
+      let description = options.description;
+      if (!description && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        description = Buffer.concat(chunks).toString('utf-8');
+      }
+
+      if (!processManager.isRecordingActive()) {
+        console.log('No active recording to create clip from');
+        console.log('Start a recording first with "dashcam record" or "dashcam start"');
+        process.exit(0);
+      }
+
+      const activeStatus = processManager.getActiveStatus();
+      
+      console.log('Creating clip from recording...');
+      
+      const result = await processManager.stopActiveRecording();
+      
+      if (!result) {
+        console.log('Failed to stop recording');
+        process.exit(1);
+      }
+
+      console.log('Recording stopped successfully');
+      
+      // Upload the recording
+      console.log('Uploading clip...');
+      try {
+        const uploadResult = await upload(result.outputPath, {
+          title: options.title || activeStatus?.options?.title || 'Dashcam Recording',
+          description: description || activeStatus?.options?.description,
+          project: options.project || options.k || activeStatus?.options?.project,
+          duration: result.duration,
+          clientStartDate: result.clientStartDate,
+          apps: result.apps,
+          icons: result.icons,
+          gifPath: result.gifPath,
+          snapshotPath: result.snapshotPath
+        });
+        
+        // Output based on format option
+        if (options.md) {
+          const replayId = uploadResult.replay?.id;
+          const shareKey = uploadResult.shareLink.split('share=')[1];
+          console.log(`[![Dashcam - ${options.title || 'New Replay'}](https://replayable-api-production.herokuapp.com/replay/${replayId}/gif?shareKey=${shareKey})](${uploadResult.shareLink})`);
+          console.log('');
+          console.log(`Watch [Dashcam - ${options.title || 'New Replay'}](${uploadResult.shareLink}) on Dashcam`);
+        } else {
+          console.log(uploadResult.shareLink);
+        }
+      } catch (uploadError) {
+        console.error('Upload failed:', uploadError.message);
+        console.log('Recording saved locally:', result.outputPath);
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      logger.error('Error creating clip:', error);
+      console.error('Failed to create clip:', error.message);
+      process.exit(1);
+    }
+  });
+
 // 'record' command - the main recording command with all options
 program
   .command('record')
@@ -211,6 +238,254 @@ program
   .option('-s, --silent', 'Silent mode - suppress all output')
   .action(recordingAction);
 
+program
+  .command('pipe')
+  .description('Pipe command output to dashcam to be included in recorded video')
+  .action(async () => {
+    try {
+      // Check if recording is active
+      if (!processManager.isRecordingActive()) {
+        console.error('No active recording. Start a recording first with "dashcam record" or "dashcam start"');
+        process.exit(1);
+      }
+
+      // Read from stdin
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+        // Also output to stdout so pipe continues to work
+        process.stdout.write(chunk);
+      }
+      const content = Buffer.concat(chunks).toString('utf-8');
+
+      // Import the log tracker to add the piped content
+      const { logsTrackerManager } = await import('../lib/logs/index.js');
+      
+      // Add piped content as a log entry
+      logsTrackerManager.addPipedLog(content);
+      
+      process.exit(0);
+    } catch (error) {
+      logger.error('Failed to pipe content:', error);
+      console.error('Failed to pipe content:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show current recording status')
+  .action(() => {
+    const activeStatus = processManager.getActiveStatus();
+    if (activeStatus) {
+      const duration = ((Date.now() - activeStatus.startTime) / 1000).toFixed(1);
+      console.log('Recording in progress');
+      console.log(`Duration: ${duration} seconds`);
+      console.log(`PID: ${activeStatus.pid}`);
+      console.log(`Started: ${new Date(activeStatus.startTime).toLocaleString()}`);
+      if (activeStatus.options.title) {
+        console.log(`Title: ${activeStatus.options.title}`);
+      }
+    } else {
+      console.log('No active recording');
+    }
+    process.exit(0);
+  });
+
+
+
+// 'start' command - alias for record with simple instant replay mode
+program
+  .command('start')
+  .description('Start instant replay recording on dashcam')
+  .action(async () => {
+    // Call recordingAction with minimal options for instant replay
+    await recordingAction({ 
+      fps: '30', 
+      audio: false, 
+      silent: false 
+    }, null);
+  });
+
+program
+  .command('track')
+  .description('Add a logs config to Dashcam')
+  .option('--name <name>', 'Name for the tracking configuration (required)')
+  .option('--type <type>', 'Type of tracker: "application" or "web" (required)')
+  .option('--pattern <pattern>', 'Pattern to track (can be used multiple times)', (value, previous) => {
+    return previous ? previous.concat([value]) : [value];
+  })
+  .option('--web <pattern>', 'Web URL pattern to track (can use wildcards like *) - deprecated, use --type=web --pattern instead')
+  .option('--app <pattern>', 'Application file pattern to track (can use wildcards like *) - deprecated, use --type=application --pattern instead')
+  .action(async (options) => {
+    try {
+      // Support both old and new syntax
+      // New syntax: --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"
+      // Old syntax: --web <pattern> --app <pattern>
+      
+      if (options.type && options.pattern) {
+        // New syntax validation
+        if (!options.name) {
+          console.error('Error: --name is required when using --type and --pattern');
+          console.log('Example: dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
+          process.exit(1);
+        }
+        
+        if (options.type !== 'web' && options.type !== 'application') {
+          console.error('Error: --type must be either "web" or "application"');
+          process.exit(1);
+        }
+        
+        const config = {
+          name: options.name,
+          type: options.type,
+          patterns: options.pattern,
+          enabled: true
+        };
+        
+        await createPattern(config);
+        console.log(`${options.type === 'web' ? 'Web' : 'Application'} tracking pattern added successfully:`, options.name);
+        console.log('Patterns:', options.pattern.join(', '));
+        
+      } else if (options.web || options.app) {
+        // Old syntax for backward compatibility
+        if (options.web) {
+          const config = {
+            name: options.name || 'Web Pattern',
+            type: 'web',
+            patterns: [options.web],
+            enabled: true
+          };
+          
+          await createPattern(config);
+          console.log('Web tracking pattern added successfully:', options.web);
+        }
+
+        if (options.app) {
+          const config = {
+            name: options.name || 'App Pattern',
+            type: 'application',
+            patterns: [options.app],
+            enabled: true
+          };
+          
+          await createPattern(config);
+          console.log('Application tracking pattern added successfully:', options.app);
+        }
+      } else {
+        console.error('Error: Must provide either:');
+        console.log('  --name --type --pattern (new syntax)');
+        console.log('  --web or --app (old syntax)');
+        console.log('\nExamples:');
+        console.log('  dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
+        console.log('  dashcam track --web "*facebook.com*"');
+        process.exit(1);
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error('Failed to add tracking pattern:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('stop')
+  .description('Stop the current recording and wait for upload completion')
+  .action(async () => {
+    try {
+      // Enable verbose logging for stop command
+      setVerbose(true);
+      
+      if (!processManager.isRecordingActive()) {
+        console.log('No active recording to stop');
+        process.exit(0);
+      }
+
+      const activeStatus = processManager.getActiveStatus();
+      const logFile = path.join(process.cwd(), '.dashcam', 'recording.log');
+
+      console.log('Stopping recording...');
+      
+      try {
+        const result = await processManager.stopActiveRecording();
+        
+        if (!result) {
+          console.log('Failed to stop recording');
+          process.exit(1);
+        }
+
+        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
+          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));
+        
+        if (!filesExist) {
+          console.log('✅ Recording uploaded by background process');
+          logger.info('Files were cleaned up by background process');
+          process.exit(0);
+        }
+        
+        // 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, // May be undefined, that's ok
+            duration: result.duration,
+            clientStartDate: result.clientStartDate,
+            apps: result.apps,
+            icons: result.icons,
+            gifPath: result.gifPath,
+            snapshotPath: result.snapshotPath
+          });
+          
+          console.log('📹 Watch your recording:', uploadResult.shareLink);
+        } catch (uploadError) {
+          console.error('Upload failed:', uploadError.message);
+          console.log('Recording saved locally:', result.outputPath);
+        }
+      } catch (error) {
+        console.error('Failed to stop recording:', error.message);
+        process.exit(1);
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      logger.error('Error stopping recording:', error);
+      console.error('Failed to stop recording:', error.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('logs')
   .description('Manage log tracking for recordings')
@@ -337,4 +612,84 @@ program
     }
   });
 
+program
+  .command('upload')
+  .description('Upload a completed recording file or recover from interrupted recording')
+  .argument('[filePath]', 'Path to the recording file to upload (optional)')
+  .option('-t, --title <title>', 'Title for the recording')
+  .option('-d, --description <description>', 'Description for the recording')
+  .option('-p, --project <project>', 'Project ID to upload to')
+  .option('--recover', 'Attempt to recover and upload from interrupted recording')
+  .action(async (filePath, options) => {
+    try {
+      let targetFile = filePath;
+      
+      if (options.recover) {
+        // Try to recover from interrupted recording
+        const tempFileInfoPath = path.join(process.cwd(), '.dashcam', 'temp-file.json');
+        
+        if (fs.existsSync(tempFileInfoPath)) {
+          console.log('Found interrupted recording, attempting recovery...');
+          
+          const tempFileInfo = JSON.parse(fs.readFileSync(tempFileInfoPath, 'utf8'));
+          const tempFile = tempFileInfo.tempFile;
+          
+          if (fs.existsSync(tempFile) && fs.statSync(tempFile).size > 0) {
+            console.log('Recovering recording from temp file...');
+            
+            // Import recorder to finalize the interrupted recording
+            const { stopRecording } = await import('../lib/recorder.js');
+            
+            try {
+              // This will attempt to finalize the temp file
+              const result = await stopRecording();
+              targetFile = result.outputPath;
+              console.log('Recovery successful:', result.outputPath);
+            } catch (error) {
+              console.error('Recovery failed:', error.message);
+              console.log('You can try uploading the temp file directly:', tempFile);
+              targetFile = tempFile;
+            }
+            
+            // Clean up temp file info after recovery attempt
+            fs.unlinkSync(tempFileInfoPath);
+          } else {
+            console.log('No valid temp file found for recovery');
+            process.exit(1);
+          }
+        } else {
+          console.log('No interrupted recording found');
+          process.exit(1);
+        }
+      }
+      
+      if (!targetFile) {
+        console.error('Please provide a file path or use --recover option');
+        console.log('Examples:');
+        console.log('  dashcam upload /path/to/recording.webm');
+        console.log('  dashcam upload --recover');
+        process.exit(1);
+      }
+      
+      if (!fs.existsSync(targetFile)) {
+        console.error('File not found:', targetFile);
+        process.exit(1);
+      }
+      
+      console.log('Uploading recording...');
+      const uploadResult = await upload(targetFile, {
+        title: options.title,
+        description: options.description,
+        project: options.project
+      });
+      
+      console.log('✅ Upload complete! Share link:', uploadResult.shareLink);
+      process.exit(0);
+      
+    } catch (error) {
+      console.error('Upload failed:', error.message);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/lib/config.js

@@ -1,10 +1,16 @@
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
+import { readFileSync } from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Read version from package.json
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
+);
+
 export const ENV = process.env.NODE_ENV || 'production';
 
 export const auth0Config = {
@@ -26,7 +32,7 @@ export const API_ENDPOINT = apiEndpoints[ENV];
 export const APP = {
   id: 'dashcam-cli',
   name: ENV === 'production' ? 'Dashcam CLI' : `Dashcam CLI - ${ENV}`,
-  version: process.env.npm_package_version || '1.0.0',
+  version: packageJson.version,
   configDir: join(homedir(), '.dashcam'),
   logsDir: join(homedir(), '.dashcam', 'logs'),
   recordingsDir: join(homedir(), '.dashcam', 'recordings'),

package/lib/processManager.js

@@ -0,0 +1,306 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { logger } from './logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+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');
+
+// Ensure process directory exists
+if (!fs.existsSync(PROCESS_DIR)) {
+  fs.mkdirSync(PROCESS_DIR, { recursive: true });
+}
+
+class ProcessManager {
+  constructor() {
+    this.isBackgroundMode = false;
+    this.isStopping = false;
+  }
+
+  setBackgroundMode(enabled = true) {
+    this.isBackgroundMode = enabled;
+  }
+
+  writeStatus(status) {
+    try {
+      fs.writeFileSync(STATUS_FILE, JSON.stringify({
+        ...status,
+        timestamp: Date.now(),
+        pid: process.pid
+      }, null, 2));
+    } catch (error) {
+      logger.error('Failed to write status file', { error });
+    }
+  }
+
+  readStatus() {
+    try {
+      if (!fs.existsSync(STATUS_FILE)) return null;
+      const data = fs.readFileSync(STATUS_FILE, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.error('Failed to read status file', { error });
+      return null;
+    }
+  }
+
+  writeUploadResult(result) {
+    try {
+      logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
+      fs.writeFileSync(RESULT_FILE, JSON.stringify({
+        ...result,
+        timestamp: Date.now()
+      }, null, 2));
+      logger.info('Successfully wrote upload result to file');
+      // Verify it was written
+      if (fs.existsSync(RESULT_FILE)) {
+        logger.info('Verified upload result file exists');
+      } else {
+        logger.error('Upload result file does not exist after write!');
+      }
+    } catch (error) {
+      logger.error('Failed to write upload result file', { error });
+    }
+  }
+
+  readUploadResult() {
+    try {
+      if (!fs.existsSync(RESULT_FILE)) return null;
+      const data = fs.readFileSync(RESULT_FILE, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.error('Failed to read upload result file', { error });
+      return null;
+    }
+  }
+
+  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 {
+      process.kill(pid, 0); // Signal 0 just checks if process exists
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  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 });
+      return false;
+    }
+    
+    return status && status.isRecording;
+  }
+
+  getActiveStatus() {
+    if (!this.isRecordingActive()) return null;
+    return this.readStatus();
+  }
+
+  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);
+      if (!preserveResult && fs.existsSync(RESULT_FILE)) fs.unlinkSync(RESULT_FILE);
+    } catch (error) {
+      logger.error('Failed to cleanup process files', { error });
+    }
+  }
+
+  async stopActiveRecording() {
+    if (this.isStopping) {
+      logger.info('Stop already in progress, ignoring additional stop request');
+      return false;
+    }
+    
+    this.isStopping = true;
+    
+    try {
+      const pid = this.readPid();
+      const status = this.readStatus();
+      
+      if (!pid || !this.isProcessRunning(pid)) {
+        logger.warn('No active recording process found');
+        return false;
+      }
+      
+      // Recording is active, send SIGINT to trigger graceful shutdown
+      logger.info('Stopping active recording process', { pid });
+      process.kill(pid, 'SIGINT');
+      
+      // Wait for the process to actually finish and upload
+      // Increase timeout to allow for upload to complete
+      const maxWaitTime = 120000; // 2 minutes max to allow for upload
+      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, forcing termination');
+        process.kill(pid, 'SIGKILL');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+      
+      // The background process handles stopRecording() internally via SIGINT
+      // We just need to return the basic result from the status file
+      if (status) {
+        logger.info('Background 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');
+      }
+    } catch (error) {
+      logger.error('Failed to stop recording', { error });
+      throw error;
+    } finally {
+      this.isStopping = false;
+    }
+  }
+
+  async startRecording(options) {
+    // Check if recording is already active
+    if (this.isRecordingActive()) {
+      throw new Error('Recording already in progress');
+    }
+
+    // Always run in background mode by spawning a detached process
+    logger.info('Starting recording in background mode');
+    
+    // Get the path to the CLI binary
+    const binPath = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
+    
+    logger.debug('Background process path', { binPath, exists: fs.existsSync(binPath) });
+    
+    // Create log files for background process 
+    const logDir = PROCESS_DIR;
+    const stdoutLog = path.join(logDir, 'background-stdout.log');
+    const stderrLog = path.join(logDir, 'background-stderr.log');
+    
+    // Always use 'ignore' for stdio to ensure complete detachment
+    // This is critical when parent process is invoked via exec() or other methods
+    // that might have open stdio pipes
+    const isWindows = process.platform === 'win32';
+    
+    // Spawn a detached process that will handle the recording
+    const backgroundProcess = spawn(process.execPath, [
+      binPath,
+      JSON.stringify(options)
+    ], {
+      detached: true,
+      stdio: 'ignore', // Always ignore to prevent hanging when parent has open pipes
+      windowsHide: true, // Hide the console window on Windows
+      env: {
+        ...process.env,
+        DASHCAM_BACKGROUND: 'true'
+      }
+    });
+
+    // Get the background process PID before unreffing
+    const backgroundPid = backgroundProcess.pid;
+    
+    // Write PID file immediately so other commands can find the background process
+    // Use the spawned process PID rather than waiting for status file
+    this.writePid(backgroundPid);
+    
+    // Allow the parent process to exit independently
+    backgroundProcess.unref();
+
+    // Wait a moment for the background process to initialize
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Read the status file to get recording details
+    const status = this.readStatus();
+    
+    if (!status || !status.isRecording) {
+      // Clean up PID file if recording failed to start
+      this.cleanup();
+      throw new Error('Background process failed to start recording');
+    }
+
+    logger.info('Background recording process started', { 
+      pid: status.pid,
+      outputPath: status.outputPath
+    });
+
+    return {
+      pid: status.pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime
+    };
+  }
+
+  async gracefulExit() {
+    logger.info('Graceful exit requested');
+    
+    // If we're currently recording, stop it properly
+    if (this.isRecordingActive()) {
+      try {
+        logger.info('Stopping active recording before exit');
+        await this.stopActiveRecording();
+        logger.info('Recording stopped successfully during graceful exit');
+      } catch (error) {
+        logger.error('Failed to stop recording during graceful exit', { error });
+        this.cleanup(); // Fallback cleanup
+      }
+    } else {
+      // Just cleanup if no recording is active
+      this.cleanup();
+    }
+    
+    process.exit(0);
+  }
+}
+
+const processManager = new ProcessManager();
+
+export { processManager };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dashcam",
-  "version": "1.1.0-beta.5",
+  "version": "1.3.0-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
-  "main": "bin/index.js",
+  "main": "bin/dashcam.js",
   "bin": {
     "dashcam": "./bin/dashcam.js"
   },

package/test_workflow.sh

@@ -30,16 +30,16 @@ if [ ! -f "$TEMP_FILE" ]; then
 fi
 echo "✅ File tracking configured"
 
-# 4. Start dashcam recording in background with timeout to auto-stop
+# 4. Start dashcam recording in background
 echo ""
-echo "4. Starting dashcam recording..."
-# Start recording in background and set up auto-stop after test duration
+echo "4. Starting dashcam recording in background..."
+# Start recording and redirect output to a log file so we can still monitor it
 ./bin/dashcam.js record --title "Sync Test Recording" --description "Testing video/log synchronization with timestamped events" > /tmp/dashcam-recording.log 2>&1 &
 RECORD_PID=$!
 
 # Wait for recording to initialize and log tracker to start
 echo "Waiting for recording to initialize (PID: $RECORD_PID)..."
-sleep 2
+sleep 1
 
 # Write first event after log tracker is fully ready
 RECORDING_START=$(date +%s)
@@ -53,7 +53,6 @@ if ps -p $RECORD_PID > /dev/null; then
   echo "✅ Recording started successfully"
 else
   echo "❌ Recording process died, check /tmp/dashcam-recording.log"
-  cat /tmp/dashcam-recording.log
   exit 1
 fi
 
@@ -110,28 +109,15 @@ echo ""
 echo "Waiting 2 seconds to ensure all events are captured..."
 sleep 2
 
-# 6. Stop recording by sending SIGINT (Ctrl+C) to the recording process
+# 6. Stop recording and upload (this will kill the background recording process)
 echo ""
-echo "6. Stopping recording (sending SIGINT)..."
+echo "6. Stopping recording and uploading..."
 # Check if recording is still active
-if ps -p $RECORD_PID > /dev/null; then
-  kill -INT $RECORD_PID
-  echo "Sent SIGINT to recording process, waiting for upload to complete..."
-  
-  # Wait for the process to finish (it will stop recording and upload)
-  wait $RECORD_PID 2>/dev/null || true
-  
-  echo "✅ Recording stopped and upload completed"
-  
-  # Show the output from the recording process
-  echo ""
-  echo "Recording output:"
-  cat /tmp/dashcam-recording.log
+if ./bin/dashcam.js status | grep -q "Recording in progress"; then
+  ./bin/dashcam.js stop
+  echo "✅ Recording stopped and uploaded"
 else
-  echo "⚠️  Recording process already completed"
-  echo ""
-  echo "Recording output:"
-  cat /tmp/dashcam-recording.log
+  echo "⚠️  Recording already completed (this is expected with background mode)"
 fi
 
 echo ""
@@ -141,6 +127,11 @@ echo ""
 echo "🎉 Test workflow completed successfully!"
 echo "======================================"
 
+# Show final status
+echo ""
+echo "📊 Final Status:"
+./bin/dashcam.js status
+
 echo ""
 echo "╔════════════════════════════════════════════════════════════════╗"
 echo "║                  SYNC VERIFICATION GUIDE                       ║"