dashcam 0.8.3 → 1.0.1-beta.10

package/lib/ffmpeg.js

@@ -0,0 +1,155 @@
+import { execa } from 'execa';
+import { logger } from './logger.js';
+import { getFfmpegPath, getFfprobePath } from './binaries.js';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Create a snapshot (PNG) from a video at a specific timestamp
+ */
+export async function createSnapshot(inputVideoPath, outputSnapshotPath, snapshotTimeSeconds = 0) {
+  logger.debug('Creating snapshot', { inputVideoPath, outputSnapshotPath, snapshotTimeSeconds });
+  
+  const ffmpegPath = await getFfmpegPath();
+  
+  const command = [
+    '-ss', snapshotTimeSeconds,
+    '-i', inputVideoPath,
+    '-frames:v', '1',
+    '-vf', 'scale=640:-1:force_original_aspect_ratio=decrease:eval=frame',
+    '-compression_level', '6', // Use default compression (was 100, which is extremely slow)
+    outputSnapshotPath,
+    '-y',
+    '-hide_banner'
+  ];
+
+  await execa(ffmpegPath, command);
+}
+
+/**
+ * Create an animated GIF from a video
+ */
+export async function createGif(inputVideoPath, outputGifPath) {
+  logger.debug('Creating GIF', { inputVideoPath, outputGifPath });
+
+  const ffmpegPath = await getFfmpegPath();
+  const ffprobePath = await getFfprobePath();
+
+  // Function to check if video is ready
+  const isVideoReady = async () => {
+    try {
+      // Check if file exists and is not empty
+      if (!fs.existsSync(inputVideoPath) || fs.statSync(inputVideoPath).size === 0) {
+        return false;
+      }
+
+      // Try to read video info with ffprobe
+      const { exitCode } = await execa(ffprobePath, [
+        '-v', 'error',
+        '-select_streams', 'v:0',
+        '-show_entries', 'stream=codec_type',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        inputVideoPath
+      ], { reject: false });
+
+      return exitCode === 0;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  // Wait for up to 5 seconds for the video to be ready
+  for (let i = 0; i < 10; i++) {
+    if (await isVideoReady()) {
+      break;
+    }
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+
+  // Final check
+  if (!await isVideoReady()) {
+    throw new Error('Video file is not ready or is corrupted');
+  }
+
+  const gifFps = 4;
+  const gifDuration = 10;
+  const gifFrames = Math.ceil(gifDuration * gifFps);
+
+  // Get video duration in seconds
+  const { stdout } = await execa(ffprobePath, [
+    '-v', 'error',
+    '-show_entries', 'format=duration',
+    '-of', 'default=noprint_wrappers=1:nokey=1',
+    inputVideoPath
+  ]);
+
+  const videoDuration = parseFloat(stdout);
+  const id = (Math.random() + 1).toString(36).substring(7);
+  
+  // Handle NaN or invalid duration
+  if (!videoDuration || isNaN(videoDuration) || videoDuration <= 0) {
+    logger.warn('Video duration unavailable or invalid, using default sampling for GIF', {
+      duration: videoDuration,
+      stdout
+    });
+    
+    // Fallback: Just sample the video at a fixed rate (e.g., 1 frame every 3 seconds)
+    const framesPath = path.join(os.tmpdir(), `frames_${id}_%04d.png`);
+    await execa(ffmpegPath, [
+      '-i', inputVideoPath,
+      '-vf', `fps=1/3`, // Sample 1 frame every 3 seconds
+      framesPath
+    ]);
+
+    // Create GIF from frames
+    await execa(ffmpegPath, [
+      '-framerate', `${gifFps}`,
+      '-i', framesPath,
+      '-loop', '0',
+      outputGifPath,
+      '-y',
+      '-hide_banner'
+    ]);
+
+    // Clean up temporary frame files
+    const framesToDelete = fs.readdirSync(os.tmpdir())
+      .filter(file => file.startsWith(`frames_${id}_`) && file.endsWith('.png'))
+      .map(file => path.join(os.tmpdir(), file));
+    
+    for (const frame of framesToDelete) {
+      fs.unlinkSync(frame);
+    }
+    
+    return;
+  }
+  
+  const extractedFramesInterval = videoDuration / gifFrames;
+
+  // Extract frames
+  const framesPath = path.join(os.tmpdir(), `frames_${id}_%04d.png`);
+  await execa(ffmpegPath, [
+    '-i', inputVideoPath,
+    '-vf', `fps=1/${extractedFramesInterval}`,
+    framesPath
+  ]);
+
+  // Create GIF from frames
+  await execa(ffmpegPath, [
+    '-framerate', `${gifFps}`,
+    '-i', framesPath,
+    '-loop', '0',
+    outputGifPath,
+    '-y',
+    '-hide_banner'
+  ]);
+
+  // Clean up temporary frame files
+  const framesToDelete = fs.readdirSync(os.tmpdir())
+    .filter(file => file.startsWith(`frames_${id}_`) && file.endsWith('.png'))
+    .map(file => path.join(os.tmpdir(), file));
+  
+  for (const frame of framesToDelete) {
+    fs.unlinkSync(frame);
+  }
+}

package/lib/logTracker.js

@@ -0,0 +1,23 @@
+import { LogsTracker } from './tracking/LogsTracker.js';
+import { FileTrackerManager } from './tracking/FileTrackerManager.js';
+
+// Create a shared file tracker manager for efficient resource usage
+const fileTrackerManager = new FileTrackerManager();
+
+// Create a singleton instance for watch-only mode (no directory)
+const logTracker = new LogsTracker({ 
+  config: {},
+  fileTrackerManager 
+});
+
+// Helper function to create a new tracker for recording (with directory)
+export function createRecordingTracker(directory, config = {}) {
+  return new LogsTracker({
+    config,
+    directory,
+    fileTrackerManager
+  });
+}
+
+// Export the singleton for backwards compatibility
+export { logTracker, fileTrackerManager };

package/lib/logger.js

@@ -0,0 +1,118 @@
+import winston from 'winston';
+import os from 'os';
+import path from 'path';
+
+// Constants that match the desktop app
+const DD_TOKEN = process.env.DD_TOKEN || 'pubfd7949e46d22d1e71fc8fa6d95ecc5f2';
+const ENV = process.env.NODE_ENV || 'production';
+
+// Configure HTTP transport for Datadog
+const httpTransportOptions = {
+  host: 'http-intake.logs.datadoghq.com',
+  path: `/api/v2/logs?dd-api-key=${DD_TOKEN}`,
+  ssl: true,
+  level: 'silly'
+};
+
+// Metadata that matches the desktop app
+const httpMeta = {
+  ddsource: 'nodejs',
+  service: 'dashcam-cli',
+  env: ENV,
+  os_type: os.type(),
+  os_release: os.release()
+};
+
+// Verbose level configuration
+let isVerbose = false;
+
+// Create custom format to include version and user info
+const updateFormat = winston.format((info) => {
+  info.version = process.env.npm_package_version;
+  return info;
+});
+
+// Custom format for console output with more detail
+const verboseConsoleFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'HH:mm:ss.SSS' }),
+  winston.format.colorize(),
+  winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    let output = `${timestamp} [${level}] ${message}`;
+    
+    // Add metadata if present and in verbose mode
+    if (isVerbose && Object.keys(meta).length > 0) {
+      // Filter out internal winston metadata
+      const cleanMeta = Object.fromEntries(
+        Object.entries(meta).filter(([key]) => 
+          !['timestamp', 'level', 'message', 'ddsource', 'service', 'env', 'os_type', 'os_release', 'version'].includes(key)
+        )
+      );
+      
+      if (Object.keys(cleanMeta).length > 0) {
+        output += `\n  ${JSON.stringify(cleanMeta, null, 2).split('\n').join('\n  ')}`;
+      }
+    }
+    
+    return output;
+  })
+);
+
+// Function to set verbose mode
+export function setVerbose(verbose = true) {
+  isVerbose = verbose;
+  // Update console transport level based on verbose mode
+  const consoleTransport = logger.transports.find(t => t.constructor.name === 'Console');
+  if (consoleTransport) {
+    consoleTransport.level = verbose ? 'silly' : (ENV === 'production' ? 'info' : 'debug');
+  }
+}
+
+// Create the logger instance
+export const logger = winston.createLogger({
+  format: winston.format.combine(
+    updateFormat(),
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: {
+    ...httpMeta
+  },
+  transports: [
+    // Log to console in development with enhanced formatting
+    new winston.transports.Console({
+      format: verboseConsoleFormat,
+      level: ENV === 'production' ? 'info' : 'debug'
+    }),
+    // Log to files
+    new winston.transports.File({
+      filename: path.join(os.homedir(), '.dashcam', 'logs', 'error.log'),
+      level: 'error'
+    }),
+    new winston.transports.File({
+      filename: path.join(os.homedir(), '.dashcam', 'logs', 'combined.log'),
+      level: 'silly' // Capture all levels in file
+    }),
+    // Log debug info to separate file when verbose
+    new winston.transports.File({
+      filename: path.join(os.homedir(), '.dashcam', 'logs', 'debug.log'),
+      level: 'debug'
+    }),
+    // Send to Datadog in production
+    ...(ENV === 'production' ? [new winston.transports.Http(httpTransportOptions)] : [])
+  ]
+});
+
+// Add convenience methods for common logging patterns
+logger.verbose = (message, meta) => logger.debug(`[VERBOSE] ${message}`, meta);
+logger.trace = (message, meta) => logger.silly(`[TRACE] ${message}`, meta);
+
+// Function to log function entry/exit for debugging
+export function logFunctionCall(functionName, args = {}) {
+  if (isVerbose) {
+    logger.debug(`→ Entering ${functionName}`, { args });
+    return (result) => {
+      logger.debug(`← Exiting ${functionName}`, { result: typeof result });
+    };
+  }
+  return () => {}; // No-op if not verbose
+}