dashcam 1.3.10-beta → 1.3.13-beta

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/lib/processManager.js

@@ -0,0 +1,307 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+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 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;
+    }
+  }
+
+  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 status = this.readStatus();
+    
+    if (!status || !status.pid || !this.isProcessRunning(status.pid)) {
+      // Clean up but preserve upload result in case the background process just finished uploading
+      this.cleanup({ preserveResult: true });
+      return false;
+    }
+    
+    return status.isRecording;
+  }
+
+  getActiveStatus() {
+    if (!this.isRecordingActive()) return null;
+    return this.readStatus();
+  }
+
+  cleanup(options = {}) {
+    const { preserveResult = false } = options;
+    try {
+      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 status = this.readStatus();
+      
+      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 });
+        return false;
+      }
+      
+      logger.info('Sending stop signal to background process', { pid });
+      
+      // Send SIGTERM to the background process to trigger graceful shutdown
+      try {
+        process.kill(pid, 'SIGTERM');
+        logger.info('Sent SIGTERM to background process');
+      } catch (error) {
+        logger.error('Failed to send signal to background process', { error });
+        throw new Error('Failed to stop background recording process');
+      }
+      
+      // Wait for the background process to finish and write results
+      logger.debug('Waiting for background process to complete...');
+      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.error('Background process did not exit within timeout, forcing kill');
+        try {
+          process.kill(pid, 'SIGKILL');
+        } catch (error) {
+          logger.error('Failed to force kill background process', { error });
+        }
+      }
+      
+      logger.info('Background process stopped');
+      
+      // Return a minimal result indicating success
+      // The upload will be handled by the stop command checking the result file
+      return {
+        outputPath: status.outputPath,
+        duration: Date.now() - status.startTime
+      };
+      
+    } 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');
+    }
+
+    // Spawn background process
+    const backgroundScriptPath = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
+    
+    logger.info('Starting background recording process', { 
+      backgroundScriptPath,
+      options 
+    });
+
+    // Serialize options to pass to background process
+    const optionsJson = JSON.stringify(options);
+    
+    // Determine node executable path
+    const nodePath = process.execPath;
+    
+    // Create log file for background process output
+    const logDir = path.join(PROCESS_DIR, 'logs');
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    const logFile = path.join(logDir, `recording-${Date.now()}.log`);
+    const logStream = fs.createWriteStream(logFile, { flags: 'a' });
+    
+    logger.info('Background process log file', { logFile });
+    
+    // Spawn the background process with proper detachment
+    const child = spawn(
+      nodePath,
+      [backgroundScriptPath, optionsJson],
+      {
+        detached: true,    // Detach from parent on Unix-like systems
+        stdio: ['ignore', logStream, logStream], // Redirect output to log file
+        windowsHide: true, // Hide console window on Windows
+        shell: false       // Don't use shell to avoid extra process wrapper
+      }
+    );
+    
+    // Unref to allow parent to exit independently
+    child.unref();
+    
+    const pid = child.pid;
+    
+    logger.info('Background process spawned', { 
+      pid,
+      logFile,
+      detached: true
+    });
+    
+    // Wait for status file to be created by background process
+    logger.debug('Waiting for background process to write status file...');
+    const maxWaitTime = 10000; // 10 seconds
+    const startWait = Date.now();
+    let statusCreated = false;
+    
+    while (!statusCreated && (Date.now() - startWait) < maxWaitTime) {
+      const status = this.readStatus();
+      if (status && status.isRecording && status.pid === pid) {
+        statusCreated = true;
+        logger.debug('Status file created by background process', { status });
+        break;
+      }
+      // Wait a bit before checking again
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    
+    if (!statusCreated) {
+      logger.error('Background process did not create status file within timeout');
+      throw new Error('Failed to start background recording process - status file not created. Check log: ' + logFile);
+    }
+    
+    // Read the status to get output path and start time
+    const status = this.readStatus();
+    
+    logger.info('Recording started successfully in background', { 
+      pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime,
+      logFile
+    });
+
+    return {
+      pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime,
+      logFile
+    };
+  }
+
+  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,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.3.10-beta",
+  "version": "1.3.13-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {