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

package/test-short-recording.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for analyzing short recording issues
+ * 
+ * This tests whether very short recordings produce valid multi-frame videos
+ * with properly finalized WebM container metadata.
+ * 
+ * Known issue: If ffmpeg/VP9 encoder is killed too quickly, the WebM container
+ * metadata (especially duration) may be incomplete, causing playback issues.
+ * 
+ * Usage:
+ *   node test-short-recording.js                    # Run recording tests
+ *   node test-short-recording.js analyze <file>     # Analyze existing video
+ *   node test-short-recording.js fix <input> <output> # Fix broken video container
+ * 
+ * Platform notes:
+ *   - macOS: Uses AVFoundation for screen capture
+ *   - Linux: Uses X11grab for screen capture
+ *   - Windows: Uses gdigrab for screen capture
+ */
+
+import { startRecording, stopRecording, fixVideoContainer } from './lib/recorder.js';
+import { execa } from 'execa';
+import { getFfprobePath } from './lib/binaries.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+async function analyzeVideo(videoPath) {
+  const ffprobePath = await getFfprobePath();
+  
+  console.log(`\n📊 Analyzing video: ${videoPath}`);
+  console.log('─'.repeat(80));
+  
+  // Check if file exists
+  if (!fs.existsSync(videoPath)) {
+    console.error(`❌ Video file does not exist: ${videoPath}`);
+    return null;
+  }
+  
+  const stats = fs.statSync(videoPath);
+  console.log(`📁 File size: ${(stats.size / 1024).toFixed(2)} KB`);
+  
+  try {
+    // Get basic format info
+    const formatResult = await execa(ffprobePath, [
+      '-v', 'error',
+      '-show_entries', 'format=duration,size,bit_rate',
+      '-of', 'json',
+      videoPath
+    ]);
+    
+    const formatData = JSON.parse(formatResult.stdout);
+    console.log(`⏱️  Duration: ${formatData.format.duration || 'unknown'}s`);
+    console.log(`📊 Bit rate: ${formatData.format.bit_rate || 'unknown'} bits/s`);
+    
+    // Get stream info
+    const streamResult = await execa(ffprobePath, [
+      '-v', 'error',
+      '-show_entries', 'stream=codec_name,width,height,r_frame_rate,duration',
+      '-of', 'json',
+      videoPath
+    ]);
+    
+    const streamData = JSON.parse(streamResult.stdout);
+    const videoStream = streamData.streams.find(s => s.codec_name);
+    
+    if (videoStream) {
+      console.log(`🎥 Codec: ${videoStream.codec_name}`);
+      console.log(`📐 Resolution: ${videoStream.width}x${videoStream.height}`);
+      console.log(`🎞️  Frame rate: ${videoStream.r_frame_rate}`);
+    }
+    
+    // Count actual frames
+    const frameResult = await execa(ffprobePath, [
+      '-v', 'error',
+      '-count_frames',
+      '-select_streams', 'v:0',
+      '-show_entries', 'stream=nb_read_frames',
+      '-of', 'default=nokey=1:noprint_wrappers=1',
+      videoPath
+    ], { reject: false });
+    
+    const frameCount = parseInt(frameResult.stdout.trim());
+    console.log(`🖼️  Frame count: ${frameCount || 'unknown'}`);
+    
+    if (frameResult.stderr) {
+      console.log(`⚠️  FFprobe warnings: ${frameResult.stderr.trim()}`);
+    }
+    
+    // Check if duration is available in container
+    const hasDuration = formatData.format.duration && !isNaN(parseFloat(formatData.format.duration));
+    
+    // Determine if this is a single-frame video issue
+    const isSingleFrame = frameCount === 1;
+    const hasEncodingIssues = frameResult.stderr.includes('File ended prematurely');
+    const hasMissingMetadata = !hasDuration;
+    
+    console.log('\n📋 Analysis Result:');
+    console.log(`   Single frame: ${isSingleFrame ? '❌ YES (BUG!)' : '✅ NO'}`);
+    console.log(`   Encoding issues: ${hasEncodingIssues ? '⚠️  YES' : '✅ NO'}`);
+    console.log(`   Missing metadata: ${hasMissingMetadata ? '⚠️  YES (container incomplete)' : '✅ NO'}`);
+    console.log(`   Platform: ${os.platform()}`);
+    
+    return {
+      exists: true,
+      size: stats.size,
+      duration: parseFloat(formatData.format.duration),
+      frameCount,
+      codec: videoStream?.codec_name,
+      resolution: videoStream ? `${videoStream.width}x${videoStream.height}` : 'unknown',
+      isSingleFrame,
+      hasEncodingIssues,
+      hasMissingMetadata,
+      platform: os.platform()
+    };
+    
+  } catch (error) {
+    console.error(`❌ Error analyzing video: ${error.message}`);
+    return null;
+  }
+}
+
+async function testShortRecording(duration = 3000) {
+  console.log(`\n🎬 Testing ${duration}ms recording...`);
+  console.log('═'.repeat(80));
+  
+  try {
+    // Start recording
+    console.log('▶️  Starting recording...');
+    const { outputPath, startTime } = await startRecording({ 
+      fps: 30,
+      includeAudio: false 
+    });
+    
+    console.log(`✅ Recording started at: ${outputPath}`);
+    
+    // Wait for specified duration
+    console.log(`⏳ Recording for ${duration}ms...`);
+    await new Promise(resolve => setTimeout(resolve, duration));
+    
+    // Stop recording
+    console.log('⏹️  Stopping recording...');
+    const result = await stopRecording();
+    
+    console.log(`✅ Recording stopped`);
+    console.log(`   Duration: ${result.duration}ms`);
+    console.log(`   File: ${result.outputPath}`);
+    
+    // Analyze the output
+    await analyzeVideo(result.outputPath);
+    
+    return result;
+    
+  } catch (error) {
+    console.error(`❌ Test failed: ${error.message}`);
+    console.error(error.stack);
+    throw error;
+  }
+}
+
+async function testExistingVideo(videoPath) {
+  console.log('\n🔍 Testing existing video...');
+  console.log('═'.repeat(80));
+  
+  return await analyzeVideo(videoPath);
+}
+
+// Main test runner
+async function main() {
+  const args = process.argv.slice(2);
+  
+  console.log('\n🧪 Short Recording Test Suite');
+  console.log('═'.repeat(80));
+  console.log(`Platform: ${os.platform()}`);
+  console.log(`Architecture: ${os.arch()}`);
+  console.log(`Node version: ${process.version}`);
+  
+  if (args[0] === 'analyze' && args[1]) {
+    // Analyze existing video
+    const videoPath = path.resolve(args[1]);
+    const result = await testExistingVideo(videoPath);
+    
+    if (result?.isSingleFrame) {
+      console.log('\n❌ SINGLE-FRAME VIDEO DETECTED!');
+      process.exit(1);
+    } else if (result?.hasMissingMetadata) {
+      console.log('\n⚠️  WARNING: Video container metadata is incomplete!');
+      console.log('   This can cause playback issues in some players.');
+      console.log('   The video has frames but duration is not in the container.');
+      console.log('\n💡 Try fixing it with:');
+      console.log(`   node test-short-recording.js fix ${args[1]} ${args[1].replace(/\.(webm|mp4)$/, '-fixed.$1')}`);
+      process.exit(1);
+    }
+  } else if (args[0] === 'fix' && args[1] && args[2]) {
+    // Fix existing broken video
+    const inputPath = path.resolve(args[1]);
+    const outputPath = path.resolve(args[2]);
+    
+    console.log('\n🔧 Fixing video container...');
+    console.log('═'.repeat(80));
+    console.log(`Input:  ${inputPath}`);
+    console.log(`Output: ${outputPath}`);
+    
+    if (!fs.existsSync(inputPath)) {
+      console.error(`❌ Input file does not exist: ${inputPath}`);
+      process.exit(1);
+    }
+    
+    // Analyze before
+    console.log('\n📊 BEFORE:');
+    const beforeResult = await analyzeVideo(inputPath);
+    
+    // Fix the video
+    const fixSuccess = await fixVideoContainer(inputPath, outputPath);
+    
+    if (!fixSuccess) {
+      console.error('\n❌ Failed to fix video!');
+      process.exit(1);
+    }
+    
+    // Analyze after
+    console.log('\n📊 AFTER:');
+    const afterResult = await analyzeVideo(outputPath);
+    
+    console.log('\n✅ Video fixed successfully!');
+    console.log(`   Before: ${beforeResult?.hasMissingMetadata ? 'Missing metadata ⚠️' : 'Has metadata ✅'}`);
+    console.log(`   After:  ${afterResult?.hasMissingMetadata ? 'Missing metadata ⚠️' : 'Has metadata ✅'}`);
+    
+    if (afterResult?.hasMissingMetadata) {
+      console.log('\n⚠️  Warning: Metadata still missing after fix. The source file may be corrupted.');
+      process.exit(1);
+    }
+  } else {
+    // Run recording tests with different durations
+    const testDurations = [1000, 2000, 3000, 5000];
+    const results = [];
+    
+    for (const duration of testDurations) {
+      try {
+        const result = await testShortRecording(duration);
+        results.push({ duration, success: true, result });
+        
+        // Clean up
+        try {
+          fs.unlinkSync(result.outputPath);
+          if (result.gifPath && fs.existsSync(result.gifPath)) {
+            fs.unlinkSync(result.gifPath);
+          }
+          if (result.snapshotPath && fs.existsSync(result.snapshotPath)) {
+            fs.unlinkSync(result.snapshotPath);
+          }
+        } catch (cleanupError) {
+          console.warn(`⚠️  Cleanup warning: ${cleanupError.message}`);
+        }
+      } catch (error) {
+        results.push({ duration, success: false, error: error.message });
+      }
+      
+      // Wait between tests
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    
+    // Summary
+    console.log('\n\n📊 TEST SUMMARY');
+    console.log('═'.repeat(80));
+    
+    for (const result of results) {
+      const status = result.success ? '✅' : '❌';
+      console.log(`${status} ${result.duration}ms recording: ${result.success ? 'PASSED' : result.error}`);
+    }
+    
+    const allPassed = results.every(r => r.success);
+    if (!allPassed) {
+      console.log('\n❌ Some tests failed!');
+      process.exit(1);
+    } else {
+      console.log('\n✅ All tests passed!');
+    }
+  }
+}
+
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/test_workflow.sh

@@ -30,29 +30,30 @@ if [ ! -f "$TEMP_FILE" ]; then
 fi
 echo "✅ File tracking configured"
 
-# 4. Start dashcam recording in background
+# 4. Start dashcam recording in background with timeout to auto-stop
 echo ""
-echo "4. Starting dashcam recording in background..."
-# Start recording and redirect output to a log file so we can still monitor it
+echo "4. Starting dashcam recording..."
+# Start recording in background and set up auto-stop after test duration
 ./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 2
 
 # Write first event after log tracker is fully ready
 RECORDING_START=$(date +%s)
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 echo "🔴 EVENT 1: Recording START at $(date '+%H:%M:%S')"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "[EVENT 1] Recording started at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_START" >> "$TEMP_FILE"
+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
   echo "✅ Recording started successfully"
 else
   echo "❌ Recording process died, check /tmp/dashcam-recording.log"
+  cat /tmp/dashcam-recording.log
   exit 1
 fi
 
@@ -71,25 +72,25 @@ sleep 3
 # Event 2 - after 3 seconds
 echo ""
 echo "🟡 EVENT 2: 3 seconds mark at $(date '+%H:%M:%S')"
-echo "[EVENT 2] 3 seconds elapsed at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
+echo "[EVENT 2] 🟡 3 seconds elapsed with emoji at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
 sleep 3
 
 # Event 3 - after 6 seconds
 echo ""
 echo "🟢 EVENT 3: 6 seconds mark at $(date '+%H:%M:%S')"
-echo "[EVENT 3] 6 seconds elapsed at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
+echo "[EVENT 3] 🟢 6 seconds elapsed with emoji at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
 sleep 3
 
 # Event 4 - after 9 seconds
 echo ""
 echo "🔵 EVENT 4: 9 seconds mark at $(date '+%H:%M:%S')"
-echo "[EVENT 4] 9 seconds elapsed at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
+echo "[EVENT 4] 🔵 9 seconds elapsed with emoji at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
 sleep 3
 
 # Event 5 - after 12 seconds
 echo ""
 echo "🟣 EVENT 5: 12 seconds mark at $(date '+%H:%M:%S')"
-echo "[EVENT 5] 12 seconds elapsed at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
+echo "[EVENT 5] 🟣 12 seconds elapsed with emoji at $(date '+%H:%M:%S')" >> "$TEMP_FILE"
 sleep 3
 
 # Event 6 - before ending
@@ -98,7 +99,7 @@ echo "━━━━━━━━━━━━━━━━━━━━━━━━
 echo "⚫ EVENT 6: Recording END at $(date '+%H:%M:%S')"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 RECORDING_END=$(date +%s)
-echo "[EVENT 6] Recording ending at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_END" >> "$TEMP_FILE"
+echo "[EVENT 6] ⚫ Recording ending with emoji at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_END" >> "$TEMP_FILE"
 
 DURATION=$((RECORDING_END - RECORDING_START))
 echo ""
@@ -109,11 +110,29 @@ echo ""
 echo "Waiting 2 seconds to ensure all events are captured..."
 sleep 2
 
-# 6. Stop recording and upload (this will kill the background recording process)
+# 6. Stop recording by sending SIGINT (Ctrl+C) to the recording process
 echo ""
-echo "6. Stopping recording and uploading..."
-./bin/dashcam.js stop
-echo "✅ Recording stopped and uploaded"
+echo "6. Stopping recording (sending SIGINT)..."
+# Check if recording is still active
+if ps -p $RECORD_PID > /dev/null; then
+  kill -INT $RECORD_PID
+  echo "Sent SIGINT to recording process, waiting for upload to complete..."
+  
+  # Wait for the process to finish (it will stop recording and upload)
+  wait $RECORD_PID 2>/dev/null || true
+  
+  echo "✅ Recording stopped and upload completed"
+  
+  # Show the output from the recording process
+  echo ""
+  echo "Recording output:"
+  cat /tmp/dashcam-recording.log
+else
+  echo "⚠️  Recording process already completed"
+  echo ""
+  echo "Recording output:"
+  cat /tmp/dashcam-recording.log
+fi
 
 echo ""
 echo "🧹 Cleaning up..."
@@ -122,11 +141,6 @@ echo ""
 echo "🎉 Test workflow completed successfully!"
 echo "======================================"
 
-# Show final status
-echo ""
-echo "📊 Final Status:"
-./bin/dashcam.js status
-
 echo ""
 echo "╔════════════════════════════════════════════════════════════════╗"
 echo "║                  SYNC VERIFICATION GUIDE                       ║"
@@ -140,12 +154,12 @@ echo "3. Verify these events appear at the correct times:"
 echo ""
 echo "   Time   | Terminal Display          | Log Entry"
 echo "   -------|---------------------------|---------------------------"
-echo "   0:00   | 🔴 EVENT 1               | [EVENT 1] Recording started"
-echo "   0:03   | 🟡 EVENT 2               | [EVENT 2] 3 seconds elapsed"
-echo "   0:06   | 🟢 EVENT 3               | [EVENT 3] 6 seconds elapsed"
-echo "   0:09   | 🔵 EVENT 4               | [EVENT 4] 9 seconds elapsed"
-echo "   0:12   | 🟣 EVENT 5               | [EVENT 5] 12 seconds elapsed"
-echo "   0:15   | ⚫ EVENT 6               | [EVENT 6] Recording ending"
+echo "   0:00   | 🔴 EVENT 1               | [EVENT 1] 🔴 Recording started"
+echo "   0:03   | 🟡 EVENT 2               | [EVENT 2] 🟡 3 seconds elapsed"
+echo "   0:06   | 🟢 EVENT 3               | [EVENT 3] 🟢 6 seconds elapsed"
+echo "   0:09   | 🔵 EVENT 4               | [EVENT 4] 🔵 9 seconds elapsed"
+echo "   0:12   | 🟣 EVENT 5               | [EVENT 5] 🟣 12 seconds elapsed"
+echo "   0:15   | ⚫ EVENT 6               | [EVENT 6] ⚫ Recording ending"
 echo ""
 echo "4. The log timestamps should match the video timeline exactly"
 echo "5. Each colored event marker should appear in the video"

package/BACKWARD_COMPATIBILITY.md

@@ -1,177 +0,0 @@
-# Backward Compatibility Summary
-
-This document confirms that `dashcam-cli-minimal` now supports all commands and arguments documented in the README.md.
-
-## ✅ Implemented Commands
-
-### `auth <api-key>`
-Authenticate the dashcam desktop using a team's apiKey.
-```bash
-dashcam auth <api-key>
-```
-
-### `create [options]`
-Create a clip from current recording and output the resulting url or markdown. This stops the current recording and uploads it.
-```bash
-# Start instant replay in background
-dashcam start
-
-# Later, create a clip from the recording
-dashcam create
-dashcam create -t "My New Title"
-dashcam create --md
-dashcam create -k wef8we72h23012j
-dashcam create -d "Description text"
-cat README.md | dashcam create
-```
-
-Options:
-- `-t, --title <string>` - Title of the replay
-- `-d, --description [text]` - Replay markdown body (supports piped input)
-- `--md` - Returns rich markdown image link
-- `-k, --project <project>` - Project ID to publish to
-
-**Note:** `create` stops the current recording and creates a clip. It's similar to `stop` but focused on outputting URLs/markdown for integration with other tools.
-
-### `record [options]`
-Start a recording terminal to be included in your dashcam video recording.
-```bash
-dashcam record
-```
-
-Options:
-- `-t, --title <title>` - Title for the recording
-- `-d, --description <description>` - Description for the recording
-- `-p, --project <project>` - Project ID to upload to
-- `-a, --audio` - Include audio
-- `-f, --fps <fps>` - Frames per second
-
-### `pipe`
-Pipe command output to dashcam to be included in recorded video.
-```bash
-ping 1.1.1.1 | dashcam pipe
-cat /var/log/system.log | dashcam pipe
-```
-
-### `track [options]`
-Add a logs config to Dashcam.
-
-**New Syntax (matches README):**
-```bash
-dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"
-dashcam track --name=app-logs --type=application --pattern="/var/log/*.log"
-```
-
-**Old Syntax (still supported):**
-```bash
-dashcam track --web "*facebook.com*"
-dashcam track --app "/var/log/app.log"
-```
-
-Options:
-- `--name <name>` - Name for the tracking configuration (required with new syntax)
-- `--type <type>` - Type: "application" or "web" (required with new syntax)
-- `--pattern <pattern>` - Pattern to track (can use multiple times)
-- `--web <pattern>` - Web URL pattern (deprecated, use --type=web --pattern)
-- `--app <pattern>` - Application file pattern (deprecated, use --type=application --pattern)
-
-### `start`
-Start instant replay recording on dashcam.
-```bash
-dashcam start
-```
-
-### `stop`
-Stop the current recording and upload.
-```bash
-dashcam stop
-```
-
-### `status`
-Show current recording status.
-```bash
-dashcam status
-```
-
-## Examples from README
-
-All examples from the README should now work:
-
-### Basic usage
-```bash
-# Create a replay
-dashcam create
-# Returns: https://dashcam.io/replay/123?share=xyz
-
-# With markdown output
-dashcam create --md
-
-# With title
-dashcam create -t "My New Title"
-
-# With project
-dashcam create -k wef8we72h23012j
-
-# Attach last 20 CLI commands
-history -20 | dashcam create
-
-# Attach a logfile
-cat /var/log/system.log | dashcam create
-```
-
-### Tracking logs
-```bash
-# Track web URLs
-dashcam track --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"
-
-# Track application files
-dashcam track --name=app-logs --type=application --pattern="/var/log/*.log"
-```
-
-### Recording
-```bash
-# Start recording
-dashcam record
-
-# Pipe output into recording
-ping 1.1.1.1 | dashcam pipe
-
-# Stop recording
-dashcam stop
-```
-
-### GitHub CLI integration
-```bash
-# Create GitHub issue with replay
-gh issue create -w -t "Title" -b "`dashcam create --md`"
-
-# With system logs
-gh issue create -w -t "Title" -b "`cat /var/log/system.log | dashcam create --md`"
-
-# Create PR with replay
-gh pr create -w -t "Title" -b "`dashcam create --md`"
-
-# Append to commit
-git commit -am "`dashcam create`"
-```
-
-## Key Changes for Backward Compatibility
-
-1. **Added `create` command** - Stops current recording and creates a clip with URL/markdown output
-2. **Added `pipe` command** - Allows piping command output into recordings
-3. **Added `start` command** - Simple way to start instant replay recording in background
-4. **Updated `track` command** - Now supports both old syntax (--web, --app) and new syntax (--name, --type, --pattern)
-5. **Updated descriptions** - Match README text exactly
-6. **Updated `auth` parameter** - Changed from `<apiKey>` to `<api-key>` to match README
-7. **Added `-k` alias** - For `--project` option in `create` command
-8. **Shared implementation** - `create`, `record`, and `start` share common code to avoid duplication
-
-## Migration Notes
-
-- **`start`** - Starts instant replay recording in background (like desktop app's always-on recording)
-- **`create`** - Stops the current recording and outputs URL/markdown (perfect for CI/CD, git hooks, GitHub CLI)
-- **`record`** - Full-featured recording command with all options (terminal recording mode)
-- **`stop`** - Similar to `create` but focused on stopping and uploading vs URL output
-- Old `track` syntax still works for backward compatibility but new syntax is preferred
-- All piped input examples from README are supported
-- Can run just `dashcam` with options (defaults to `create` command)