dashcam 1.0.1-beta.25 → 1.0.1-beta.27

package/bin/dashcam.js

@@ -136,7 +136,56 @@ async function recordingAction(options, command) {
       log('Use "dashcam status" to check progress');
       log('Use "dashcam stop" to stop recording and upload');
       
-      process.exit(0);
+      // 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
+      
     } catch (error) {
       logError('Failed to start recording:', error.message);
       process.exit(1);
@@ -626,7 +675,7 @@ program
       
       if (options.recover) {
         // Try to recover from interrupted recording
-        const tempFileInfoPath = path.join(process.cwd(), '.dashcam', 'temp-file.json');
+        const tempFileInfoPath = path.join(APP.configDir, 'temp-file.json');
         
         if (fs.existsSync(tempFileInfoPath)) {
           console.log('Found interrupted recording, attempting recovery...');

package/lib/processManager.js

@@ -1,13 +1,8 @@
-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');
@@ -156,48 +151,66 @@ class ProcessManager {
         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
-        });
+      // 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');
         
-        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: []
-        };
+        // 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;
       } else {
-        throw new Error('No status information available for active recording');
+        // Different process - send signal (for backward compatibility if needed)
+        logger.info('Stopping active recording process', { pid });
+        process.kill(pid, 'SIGINT');
+        
+        // Wait for the process to actually finish
+        const maxWaitTime = 120000; // 2 minutes 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));
+        }
+        
+        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');
+        }
       }
     } catch (error) {
       logger.error('Failed to stop recording', { error });
@@ -213,67 +226,41 @@ 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');
-    
-    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'
-      }
-    });
+    // Import recorder module
+    const { startRecording: startRecorderRecording } = await import('./recorder.js');
     
-    // 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;
+    logger.info('Starting recording directly');
     
-    // Allow the parent process to exit independently
-    backgroundProcess.unref();
+    // Start recording using the recorder module
+    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));
+    const result = await startRecorderRecording(recordingOptions);
 
-    // 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 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 background process
-    this.writePid(status.pid);
+    // Write PID file so other commands can find the recording process
+    this.writePid(process.pid);
 
-    logger.info('Background recording process started', { 
-      pid: status.pid,
-      outputPath: status.outputPath
+    logger.info('Recording started successfully', { 
+      pid: process.pid,
+      outputPath: result.outputPath
     });
 
     return {
-      pid: status.pid,
-      outputPath: status.outputPath,
-      startTime: status.startTime
+      pid: process.pid,
+      outputPath: result.outputPath,
+      startTime: result.startTime
     };
   }
 

package/lib/recorder.js

@@ -4,6 +4,7 @@ import { createGif, createSnapshot } from './ffmpeg.js';
 import { applicationTracker } from './applicationTracker.js';
 import { logsTrackerManager, trimLogs } from './logs/index.js';
 import { getFfmpegPath } from './binaries.js';
+import { APP } from './config.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs';
@@ -145,8 +146,8 @@ let outputPath = null;
 let recordingStartTime = null;
 let currentTempFile = null;
 
-// File paths - use system temp for runtime data
-const DASHCAM_TEMP_DIR = path.join(os.tmpdir(), 'dashcam');
+// File paths - use APP config directory for better Windows compatibility
+const DASHCAM_TEMP_DIR = APP.configDir;
 const TEMP_FILE_INFO_PATH = path.join(DASHCAM_TEMP_DIR, 'temp-file.json');
 
 // Platform-specific configurations
@@ -238,12 +239,12 @@ async function getPlatformArgs({ fps, includeAudio }) {
 }
 
 /**
- * Clear the tmp/recordings directory
+ * Clear the recordings directory
  */
 function clearRecordingsDirectory() {
   const logExit = logFunctionCall('clearRecordingsDirectory');
   
-  const directory = path.join(process.cwd(), 'tmp', 'recordings');
+  const directory = APP.recordingsDir;
   
   try {
     if (fs.existsSync(directory)) {
@@ -281,8 +282,8 @@ function generateOutputPath() {
   const logExit = logFunctionCall('generateOutputPath');
   
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  // Use system temp directory with dashcam subdirectory
-  const directory = path.join(os.tmpdir(), 'dashcam', 'recordings');
+  // Use APP recordings directory for consistent cross-platform location
+  const directory = APP.recordingsDir;
   const filepath = path.join(directory, `recording-${timestamp}.webm`);
   
   logger.verbose('Generating output path', {

package/package.json

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

package/test-system-info.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Test script to verify system information collection
+ */
+
+import { getSystemInfo } from './lib/systemInfo.js';
+import { logger } from './lib/logger.js';
+
+async function testSystemInfo() {
+  console.log('Testing system information collection...\n');
+  
+  try {
+    const systemInfo = await getSystemInfo();
+    
+    console.log('✓ System information collected successfully\n');
+    console.log('System Information:');
+    console.log('==================\n');
+    
+    console.log('CPU:');
+    console.log(`  Brand: ${systemInfo.cpu.brand}`);
+    console.log(`  Cores: ${systemInfo.cpu.cores}`);
+    console.log(`  Speed: ${systemInfo.cpu.speed} GHz`);
+    console.log();
+    
+    console.log('Memory:');
+    console.log(`  Total: ${(systemInfo.mem.total / (1024 ** 3)).toFixed(2)} GB`);
+    console.log(`  Free: ${(systemInfo.mem.free / (1024 ** 3)).toFixed(2)} GB`);
+    console.log(`  Used: ${(systemInfo.mem.used / (1024 ** 3)).toFixed(2)} GB`);
+    console.log();
+    
+    console.log('Operating System:');
+    console.log(`  Platform: ${systemInfo.os.platform}`);
+    console.log(`  Distribution: ${systemInfo.os.distro}`);
+    console.log(`  Release: ${systemInfo.os.release}`);
+    console.log(`  Architecture: ${systemInfo.os.arch}`);
+    console.log(`  Hostname: ${systemInfo.os.hostname}`);
+    console.log();
+    
+    console.log('Graphics:');
+    console.log(`  Controllers: ${systemInfo.graphics.controllers?.length || 0}`);
+    if (systemInfo.graphics.controllers?.length > 0) {
+      systemInfo.graphics.controllers.forEach((controller, index) => {
+        console.log(`    ${index + 1}. ${controller.vendor} ${controller.model}`);
+        if (controller.vram) {
+          console.log(`       VRAM: ${controller.vram} MB`);
+        }
+      });
+    }
+    console.log(`  Displays: ${systemInfo.graphics.displays?.length || 0}`);
+    if (systemInfo.graphics.displays?.length > 0) {
+      systemInfo.graphics.displays.forEach((display, index) => {
+        console.log(`    ${index + 1}. ${display.model || 'Unknown'}`);
+        console.log(`       Resolution: ${display.currentResX}x${display.currentResY}`);
+        console.log(`       Refresh Rate: ${display.currentRefreshRate} Hz`);
+      });
+    }
+    console.log();
+    
+    console.log('System:');
+    console.log(`  Manufacturer: ${systemInfo.system.manufacturer}`);
+    console.log(`  Model: ${systemInfo.system.model}`);
+    console.log(`  Virtual: ${systemInfo.system.virtual ? 'Yes' : 'No'}`);
+    console.log();
+    
+    // Verify all required fields are present
+    console.log('Validation:');
+    console.log('===========\n');
+    
+    const validations = [
+      { name: 'CPU info', valid: !!systemInfo.cpu && !!systemInfo.cpu.brand },
+      { name: 'Memory info', valid: !!systemInfo.mem && systemInfo.mem.total > 0 },
+      { name: 'OS info', valid: !!systemInfo.os && !!systemInfo.os.platform },
+      { name: 'Graphics info', valid: !!systemInfo.graphics },
+      { name: 'System info', valid: !!systemInfo.system }
+    ];
+    
+    let allValid = true;
+    validations.forEach(v => {
+      const status = v.valid ? '✓' : '✗';
+      console.log(`${status} ${v.name}: ${v.valid ? 'OK' : 'MISSING'}`);
+      if (!v.valid) allValid = false;
+    });
+    
+    console.log();
+    
+    if (allValid) {
+      console.log('✓ All system information fields are properly populated');
+      console.log('✓ System information is ready to be uploaded to the API');
+    } else {
+      console.log('✗ Some system information is missing');
+    }
+    
+    // Show the JSON structure that would be sent to the API
+    console.log('\nJSON Structure for API:');
+    console.log('======================\n');
+    console.log(JSON.stringify(systemInfo, null, 2));
+    
+  } catch (error) {
+    console.error('✗ Failed to collect system information:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testSystemInfo();

package/test_workflow.sh

@@ -33,13 +33,16 @@ echo "✅ File tracking configured"
 # 4. Start dashcam recording in background
 echo ""
 echo "4. Starting dashcam recording in background..."
-# Start recording and redirect output to a log file so we can still monitor it
+echo "⚠️  NOTE: Recording will run in the background using nohup"
+echo ""
+
+# Use nohup to properly detach the process and keep it running
 ./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 1
+sleep 3
 
 # Write first event after log tracker is fully ready
 RECORDING_START=$(date +%s)
@@ -48,11 +51,12 @@ echo "🔴 EVENT 1: Recording START at $(date '+%H:%M:%S')"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 echo "[EVENT 1] 🔴 Recording started with emoji at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_START" >> "$TEMP_FILE"
 
-# Verify recording is actually running
-if ps -p $RECORD_PID > /dev/null; then
+# Verify recording is actually running by checking status
+if ./bin/dashcam.js status | grep -q "Recording in progress"; then
   echo "✅ Recording started successfully"
 else
-  echo "❌ Recording process died, check /tmp/dashcam-recording.log"
+  echo "❌ Recording failed to start, check /tmp/dashcam-recording.log"
+  cat /tmp/dashcam-recording.log
   exit 1
 fi