dashcam 1.0.1-beta.9 → 1.1.0-beta.3

package/bin/dashcam-background.js

@@ -1,177 +0,0 @@
-#!/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

@@ -1,317 +0,0 @@
-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
-      const maxWaitTime = 30000; // 30 seconds max
-      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));
-      }
-      
-      // Call the actual recorder's stopRecording function to get complete results
-      if (status) {
-        try {
-          const { stopRecording } = await import('./recorder.js');
-          const result = await stopRecording();
-          
-          logger.info('Recording stopped successfully via recorder', { 
-            outputPath: result.outputPath,
-            duration: result.duration,
-            hasLogs: result.logs?.length > 0,
-            hasApps: result.apps?.length > 0
-          });
-          
-          // Cleanup process files but preserve upload result for stop command
-          this.cleanup({ preserveResult: true });
-          
-          return result;
-        } catch (recorderError) {
-          logger.warn('Failed to stop via recorder, falling back to basic result', { error: recorderError.message });
-          
-          // Fallback to basic result if recorder fails
-          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');
-    
-    const stdoutFd = fs.openSync(stdoutLog, 'a');
-    const stderrFd = fs.openSync(stderrLog, 'a');
-    
-    // Spawn a detached process that will handle the recording
-    const backgroundProcess = spawn(process.execPath, [
-      binPath,
-      JSON.stringify(options)
-    ], {
-      detached: true,
-      stdio: ['ignore', stdoutFd, stderrFd], // Log stdout and stderr
-      env: {
-        ...process.env,
-        DASHCAM_BACKGROUND: 'true'
-      }
-    });
-    
-    // Close the file descriptors in the parent process
-    fs.closeSync(stdoutFd);
-    fs.closeSync(stderrFd);
-
-    // Get the background process PID before unreffing
-    const backgroundPid = backgroundProcess.pid;
-    
-    // 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) {
-      throw new Error('Background process failed to start recording');
-    }
-
-    // Write PID file so other commands can find the background process
-    this.writePid(status.pid);
-
-    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 };