dashcam 1.3.0-beta → 1.3.2-beta

package/bin/dashcam.js

@@ -99,16 +99,6 @@ async function recordingAction(options, command) {
       process.exit(1);
     }
 
-    // Check for piped input (description from stdin) if description option not set
-    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');
-    }
-
     // Check screen recording permissions (macOS only)
     const { ensurePermissions } = await import('../lib/permissions.js');
     const hasPermissions = await ensurePermissions();
@@ -126,7 +116,7 @@ async function recordingAction(options, command) {
         audio: options.audio,
         output: options.output,
         title: options.title,
-        description: description,
+        description: options.description,
         project: options.project || options.k // Support both -p and -k for project
       });
 
@@ -153,21 +143,11 @@ 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('-d, --description [text]', 'Replay markdown body')
   .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"');
@@ -192,7 +172,7 @@ program
       try {
         const uploadResult = await upload(result.outputPath, {
           title: options.title || activeStatus?.options?.title || 'Dashcam Recording',
-          description: description || activeStatus?.options?.description,
+          description: options.description || activeStatus?.options?.description,
           project: options.project || options.k || activeStatus?.options?.project,
           duration: result.duration,
           clientStartDate: result.clientStartDate,

package/lib/processManager.js

@@ -1,4 +1,3 @@
-import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -148,57 +147,36 @@ class ProcessManager {
     this.isStopping = true;
     
     try {
-      const pid = this.readPid();
       const status = this.readStatus();
       
-      if (!pid || !this.isProcessRunning(pid)) {
-        logger.warn('No active recording process found');
+      if (!status || !status.isRecording) {
+        logger.warn('No active recording found');
         return false;
       }
       
-      // Recording is active, send SIGINT to trigger graceful shutdown
-      logger.info('Stopping active recording process', { pid });
-      process.kill(pid, 'SIGINT');
+      // Import recorder module
+      const { stopRecording } = await import('./recorder.js');
       
-      // 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();
+      logger.info('Stopping recording directly');
       
-      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-      }
+      // Stop the recording
+      const result = await stopRecording();
       
-      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));
-      }
+      logger.info('Recording stopped successfully', { 
+        outputPath: result.outputPath,
+        duration: result.duration 
+      });
       
-      // 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');
-      }
+      // Update status to indicate recording stopped
+      this.writeStatus({
+        isRecording: false,
+        completedTime: Date.now(),
+        pid: process.pid
+      });
+      
+      this.cleanup({ preserveResult: true });
+      
+      return result;
     } catch (error) {
       logger.error('Failed to stop recording', { error });
       throw error;
@@ -213,69 +191,42 @@ class ProcessManager {
       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;
+    // Import recorder module
+    const { startRecording } = await import('./recorder.js');
     
-    // 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);
+    logger.info('Starting recording directly');
     
-    // Allow the parent process to exit independently
-    backgroundProcess.unref();
+    // Start recording with the provided options
+    const recordingOptions = {
+      fps: parseInt(options.fps) || 10,
+      includeAudio: options.audio || false,
+      customOutputPath: options.output || null
+    };
 
-    // Wait a moment for the background process to initialize
-    await new Promise(resolve => setTimeout(resolve, 2000));
+    logger.info('Starting recording with options', { recordingOptions });
 
-    // Read the status file to get recording details
-    const status = this.readStatus();
+    const recordingResult = await startRecording(recordingOptions);
     
-    if (!status || !status.isRecording) {
-      // Clean up PID file if recording failed to start
-      this.cleanup();
-      throw new Error('Background process failed to start recording');
-    }
+    // Write PID and status files for status tracking
+    this.writePid(process.pid);
+    
+    this.writeStatus({
+      isRecording: true,
+      startTime: recordingResult.startTime,
+      options,
+      pid: process.pid,
+      outputPath: recordingResult.outputPath
+    });
 
-    logger.info('Background recording process started', { 
-      pid: status.pid,
-      outputPath: status.outputPath
+    logger.info('Recording started successfully', { 
+      outputPath: recordingResult.outputPath,
+      startTime: recordingResult.startTime 
     });
 
     return {
-      pid: status.pid,
-      outputPath: status.outputPath,
-      startTime: status.startTime
+      pid: process.pid,
+      outputPath: recordingResult.outputPath,
+      startTime: recordingResult.startTime
     };
   }
 

package/package.json

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