dashcam 1.3.25 → 1.3.27

package/bin/dashcam-background.js

@@ -5,7 +5,6 @@
  */
 
 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';
@@ -14,7 +13,7 @@ import os from 'os';
 // Use user home directory for cross-session 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');
+const RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
 
 console.log('[Background INIT] Process directory:', PROCESS_DIR);
 console.log('[Background INIT] Status file:', STATUS_FILE);
@@ -92,16 +91,24 @@ function writeStatus(status) {
   }
 }
 
-// Write upload result file
-function writeUploadResult(result) {
+// Write recording result file
+function writeRecordingResult(result) {
   try {
+    console.log('[Background] Writing upload result to file:', RESULT_FILE);
+    console.log('[Background] Upload result data:', result);
     logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
-    fs.writeFileSync(RESULT_FILE, JSON.stringify({
+    
+    const resultData = {
       ...result,
       timestamp: Date.now()
-    }, null, 2));
+    };
+    
+    fs.writeFileSync(RESULT_FILE, JSON.stringify(resultData, null, 2));
+    console.log('[Background] Successfully wrote upload result to file');
+    console.log('[Background] File exists after write:', fs.existsSync(RESULT_FILE));
     logger.info('Successfully wrote upload result to file');
   } catch (error) {
+    console.error('[Background] Failed to write upload result file:', error.message);
     logger.error('Failed to write upload result file', { error });
   }
 }
@@ -146,7 +153,7 @@ async function runBackgroundRecording() {
       pid: process.pid
     });
 
-    // Set up signal handlers for graceful shutdown
+    // Set up signal handlers for graceful shutdown BEFORE entering wait loop
     const handleShutdown = async (signal) => {
       if (isShuttingDown) {
         logger.info('Shutdown already in progress...');
@@ -155,6 +162,7 @@ async function runBackgroundRecording() {
       isShuttingDown = true;
       
       logger.info(`Received ${signal}, stopping background recording...`);
+      console.log('[Background] Received stop signal, stopping recording...');
       
       try {
         // Stop the recording
@@ -165,28 +173,27 @@ async function runBackgroundRecording() {
             outputPath: stopResult.outputPath,
             duration: stopResult.duration 
           });
+          console.log('[Background] 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,
+          // Write recording result for stop command to upload
+          console.log('[Background] Writing recording result for stop command...');
+          writeRecordingResult({
+            outputPath: stopResult.outputPath,
             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
+            snapshotPath: stopResult.snapshotPath,
+            // Include options so stop command can use them for upload
+            title: options.title,
+            description: options.description,
+            project: options.project || options.k
           });
+          console.log('[Background] Recording result written successfully');
         }
         
         // Update status to indicate recording stopped
@@ -196,23 +203,27 @@ async function runBackgroundRecording() {
           pid: process.pid
         });
         
+        console.log('[Background] Background process exiting successfully');
         logger.info('Background process exiting successfully');
         process.exit(0);
       } catch (error) {
+        console.error('[Background] Error during shutdown:', error.message);
         logger.error('Error during shutdown:', error);
         process.exit(1);
       }
     };
     
+    // Register signal handlers
     process.on('SIGINT', () => handleShutdown('SIGINT'));
     process.on('SIGTERM', () => handleShutdown('SIGTERM'));
     
-    // Keep the process alive
+    // Keep the process alive - wait indefinitely for signals
     logger.info('Background recording is now running. Waiting for stop signal...');
-    await new Promise(() => {}); // Wait indefinitely for signals
+    console.log('[Background] Waiting for stop signal...');
     
   } catch (error) {
-    logger.error('Background recording failed:', error);
+    logger.error('Background recording setup failed:', error);
+    console.error('[Background] Recording setup failed:', error.message);
     
     // Update status to indicate failure
     writeStatus({
@@ -223,6 +234,9 @@ async function runBackgroundRecording() {
     
     process.exit(1);
   }
+  
+  // Infinite loop - process will only exit via signal handlers
+  await new Promise(() => {});
 }
 
 // Run the background recording

package/bin/dashcam.js

@@ -469,94 +469,56 @@ program
         console.log('Recording stopped successfully');
         logger.debug('Stop result:', result);
         
-        // Wait for upload to complete (background process handles this)
-        logger.debug('Waiting for background upload to complete...');
-        console.log('Checking if background process uploaded...');
+        // Wait for background process to write recording result
+        logger.debug('Waiting for recording result from background process...');
+        console.log('Waiting for recording result...');
         
-        // Wait up to 2 minutes for upload result to appear
-        const maxWaitForUpload = 120000; // 2 minutes
-        const startWaitForUpload = Date.now();
-        let uploadResult = null;
+        // Wait up to 30 seconds for recording result to appear
+        const maxWaitForResult = 30000;
+        const startWaitForResult = Date.now();
+        let recordingResult = null;
         let checkCount = 0;
         
-        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
-          uploadResult = processManager.readUploadResult();
+        while (!recordingResult && (Date.now() - startWaitForResult) < maxWaitForResult) {
+          recordingResult = processManager.readRecordingResult();
           checkCount++;
           
-          if (!uploadResult) {
-            // Log every 10 seconds to show progress
-            if (checkCount % 10 === 0) {
-              const elapsed = Math.round((Date.now() - startWaitForUpload) / 1000);
-              logger.debug(`Still waiting for background upload... (${elapsed}s elapsed)`);
-              console.log(`Waiting for background upload... (${elapsed}s)`);
+          if (!recordingResult) {
+            if (checkCount % 5 === 0) {
+              const elapsed = Math.round((Date.now() - startWaitForResult) / 1000);
+              console.log(`Waiting for recording result... (${elapsed}s)`);
             }
-            await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
+            await new Promise(resolve => setTimeout(resolve, 1000));
           }
         }
         
-        logger.debug('Upload result read attempt', { 
-          found: !!uploadResult, 
-          shareLink: uploadResult?.shareLink,
-          checksPerformed: checkCount,
-          timeElapsed: Math.round((Date.now() - startWaitForUpload) / 1000) + 's'
-        });
-        
-        if (uploadResult && uploadResult.shareLink) {
-          console.log('Watch your recording:', uploadResult.shareLink);
-          logger.info('Background process upload succeeded');
-          // Clean up the result file now that we've read it
-          processManager.cleanup();
-          process.exit(0);
-        }
-        
-        logger.debug('No upload result from background process, checking files...');
-        
-        // Check if files still exist - if not, background process already uploaded
-        const videoExists = fs.existsSync(result.outputPath);
-        const gifExists = !result.gifPath || fs.existsSync(result.gifPath);
-        const snapshotExists = !result.snapshotPath || fs.existsSync(result.snapshotPath);
-        
-        logger.debug('File existence check:', {
-          video: videoExists,
-          gif: gifExists,
-          snapshot: snapshotExists,
-          outputPath: result.outputPath,
-          gifPath: result.gifPath,
-          snapshotPath: result.snapshotPath
-        });
-        
-        const filesExist = videoExists && gifExists && snapshotExists;
-        
-        if (!filesExist) {
-          console.log('Recording appears to be uploaded by background process (files deleted)');
-          logger.info('Files were cleaned up by background process, assuming upload succeeded');
-          process.exit(0);
+        if (!recordingResult || !recordingResult.outputPath) {
+          console.error('Failed to get recording result from background process');
+          logger.error('No recording result received', { recordingResult });
+          process.exit(1);
         }
         
-        // Always attempt to upload - let upload function find project if needed
-        console.log('No upload result found, uploading from foreground process...');
-        logger.debug('Starting foreground upload with metadata:', {
-          title: activeStatus?.options?.title,
-          project: activeStatus?.options?.project,
-          duration: result.duration,
-          outputPath: result.outputPath
-        });
+        console.log('Recording result received, uploading...');
+        logger.debug('Recording result:', recordingResult);
         
         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
+          const uploadResult = await upload(recordingResult.outputPath, {
+            title: recordingResult.title || activeStatus?.options?.title || 'Dashcam Recording',
+            description: recordingResult.description || activeStatus?.options?.description,
+            project: recordingResult.project || activeStatus?.options?.project,
+            duration: recordingResult.duration,
+            clientStartDate: recordingResult.clientStartDate,
+            apps: recordingResult.apps,
+            logs: recordingResult.logs,
+            gifPath: recordingResult.gifPath,
+            snapshotPath: recordingResult.snapshotPath
           });
           
           console.log('Watch your recording:', uploadResult.shareLink);
-          logger.info('Foreground upload succeeded');
+          logger.info('Upload succeeded');
+          
+          // Clean up the result file
+          processManager.cleanup();
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           logger.error('Upload error details:', {
@@ -565,7 +527,7 @@ program
             code: uploadError.code,
             statusCode: uploadError.response?.statusCode
           });
-          console.log('Recording saved locally:', result.outputPath);
+          console.log('Recording saved locally:', recordingResult.outputPath);
         }
       } catch (error) {
         console.error('Failed to stop recording:', error.message);

package/lib/processManager.js

@@ -11,7 +11,7 @@ const __dirname = path.dirname(__filename);
 // Use user home directory for cross-session 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');
+const RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
 
 console.log('[INIT] Process Manager initialized');
 console.log('[INIT] Process directory:', PROCESS_DIR);
@@ -118,9 +118,9 @@ class ProcessManager {
     }
   }
 
-  writeUploadResult(result) {
+  writeRecordingResult(result) {
     try {
-      logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
+      logger.info('Writing recording result to file', { path: RESULT_FILE });
       fs.writeFileSync(RESULT_FILE, JSON.stringify({
         ...result,
         timestamp: Date.now()
@@ -137,13 +137,22 @@ class ProcessManager {
     }
   }
 
-  readUploadResult() {
+  readRecordingResult() {
     try {
-      if (!fs.existsSync(RESULT_FILE)) return null;
+      console.log('[ProcessManager] Checking for recording result file:', RESULT_FILE);
+      const exists = fs.existsSync(RESULT_FILE);
+      console.log('[ProcessManager] Recording result file exists:', exists);
+      
+      if (!exists) return null;
+      
       const data = fs.readFileSync(RESULT_FILE, 'utf8');
-      return JSON.parse(data);
+      console.log('[ProcessManager] Recording result file contents:', data);
+      const result = JSON.parse(data);
+      console.log('[ProcessManager] Parsed recording result:', result);
+      return result;
     } catch (error) {
-      logger.error('Failed to read upload result file', { error });
+      console.error('[ProcessManager] Failed to read recording result file:', error.message);
+      logger.error('Failed to read recording result file', { error });
       return null;
     }
   }

package/package.json

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