dashcam 1.0.1-beta.23 → 1.0.1-beta.25

package/bin/dashcam.js

@@ -417,12 +417,22 @@ program
 
         console.log('Recording stopped successfully');
         
-        // Wait a moment for upload to complete (background process handles this)
+        // Wait for upload to complete (background process handles this)
         logger.debug('Waiting for background upload to complete...');
-        await new Promise(resolve => setTimeout(resolve, 5000));
+        console.log('⏳ Uploading recording...');
+        
+        // Wait up to 2 minutes for upload result to appear
+        const maxWaitForUpload = 120000; // 2 minutes
+        const startWaitForUpload = Date.now();
+        let uploadResult = null;
+        
+        while (!uploadResult && (Date.now() - startWaitForUpload) < maxWaitForUpload) {
+          uploadResult = processManager.readUploadResult();
+          if (!uploadResult) {
+            await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
+          }
+        }
         
-        // Try to read the upload result from the background process
-        const uploadResult = processManager.readUploadResult();
         logger.debug('Upload result read attempt', { found: !!uploadResult, shareLink: uploadResult?.shareLink });
         
         if (uploadResult && uploadResult.shareLink) {

package/lib/auth.js

@@ -18,7 +18,7 @@ const auth = {
       });
       
       // Exchange API key for token
-      const { token } = await got.post('https://api.testdriver.ai/auth/exchange-api-key', {
+      const { token } = await got.post('https://testdriver-api.onrender.com/auth/exchange-api-key', {
         json: { apiKey },
         timeout: 30000 // 30 second timeout
       }).json();
@@ -34,7 +34,7 @@ const auth = {
 
       // Get user info to verify the token works
       logger.debug('Fetching user information to validate token...');
-      const user = await got.get('https://api.testdriver.ai/api/v1/whoami', {
+      const user = await got.get('https://testdriver-api.onrender.com/api/v1/whoami', {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -105,7 +105,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.get('https://api.testdriver.ai/api/v1/projects', {
+      const response = await got.get('https://testdriver-api.onrender.com/api/v1/projects', {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -160,7 +160,7 @@ const auth = {
       requestBody.project = replayData.project;
     }
     
-    const response = await got.post('https://api.testdriver.ai/api/v1/replay/upload', {
+    const response = await got.post('https://testdriver-api.onrender.com/api/v1/replay/upload', {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -188,7 +188,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.post('https://api.testdriver.ai/api/v1/logs', {
+      const response = await got.post('https://testdriver-api.onrender.com/api/v1/logs', {
         headers: {
           Authorization: `Bearer ${token}`
         },

package/lib/config.js

@@ -17,7 +17,7 @@ export const auth0Config = {
 export const apiEndpoints = {
   development: process.env.API_ENDPOINT || 'http://localhost:3000',
   staging: 'https://replayable-api-staging.herokuapp.com',
-  production: 'https://api.testdriver.ai'
+  production: 'https://testdriver-api.onrender.com'
 };
 
 export const API_ENDPOINT = apiEndpoints[ENV];

package/lib/processManager.js

@@ -160,8 +160,9 @@ class ProcessManager {
       logger.info('Stopping active recording process', { pid });
       process.kill(pid, 'SIGINT');
       
-      // Wait for the process to actually finish
-      const maxWaitTime = 30000; // 30 seconds max
+      // 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) {

package/lib/systemInfo.js

@@ -0,0 +1,141 @@
+import si from 'systeminformation';
+import { logger } from './logger.js';
+
+/**
+ * Collects comprehensive system information including CPU, memory, OS, and graphics data.
+ * This matches the data format expected by the Dashcam backend (same as desktop app).
+ * 
+ * @returns {Promise<Object>} System information object
+ */
+export async function getSystemInfo() {
+  try {
+    logger.debug('Collecting system information...');
+    
+    // Collect only essential system information quickly
+    // Graphics info can be very slow, so we skip it or use a short timeout
+    const [cpu, mem, osInfo, system] = await Promise.all([
+      si.cpu(),
+      si.mem(),
+      si.osInfo(),
+      si.system()
+    ]);
+    
+    // Try to get graphics info with a very short timeout (optional)
+    let graphics = { controllers: [], displays: [] };
+    try {
+      graphics = await Promise.race([
+        si.graphics(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Graphics timeout')), 2000))
+      ]);
+    } catch (error) {
+      logger.debug('Graphics info timed out, using empty graphics data');
+    }
+
+    const systemInfo = {
+      cpu: {
+        manufacturer: cpu.manufacturer,
+        brand: cpu.brand,
+        vendor: cpu.vendor,
+        family: cpu.family,
+        model: cpu.model,
+        stepping: cpu.stepping,
+        revision: cpu.revision,
+        voltage: cpu.voltage,
+        speed: cpu.speed,
+        speedMin: cpu.speedMin,
+        speedMax: cpu.speedMax,
+        cores: cpu.cores,
+        physicalCores: cpu.physicalCores,
+        processors: cpu.processors,
+        socket: cpu.socket,
+        cache: cpu.cache
+      },
+      mem: {
+        total: mem.total,
+        free: mem.free,
+        used: mem.used,
+        active: mem.active,
+        available: mem.available,
+        swaptotal: mem.swaptotal,
+        swapused: mem.swapused,
+        swapfree: mem.swapfree
+      },
+      os: {
+        platform: osInfo.platform,
+        distro: osInfo.distro,
+        release: osInfo.release,
+        codename: osInfo.codename,
+        kernel: osInfo.kernel,
+        arch: osInfo.arch,
+        hostname: osInfo.hostname,
+        fqdn: osInfo.fqdn,
+        codepage: osInfo.codepage,
+        logofile: osInfo.logofile,
+        build: osInfo.build,
+        servicepack: osInfo.servicepack,
+        uefi: osInfo.uefi
+      },
+      graphics: {
+        controllers: graphics.controllers?.map(controller => ({
+          vendor: controller.vendor,
+          model: controller.model,
+          bus: controller.bus,
+          vram: controller.vram,
+          vramDynamic: controller.vramDynamic
+        })),
+        displays: graphics.displays?.map(display => ({
+          vendor: display.vendor,
+          model: display.model,
+          main: display.main,
+          builtin: display.builtin,
+          connection: display.connection,
+          resolutionX: display.resolutionX,
+          resolutionY: display.resolutionY,
+          sizeX: display.sizeX,
+          sizeY: display.sizeY,
+          pixelDepth: display.pixelDepth,
+          currentResX: display.currentResX,
+          currentResY: display.currentResY,
+          currentRefreshRate: display.currentRefreshRate
+        }))
+      },
+      system: {
+        manufacturer: system.manufacturer,
+        model: system.model,
+        version: system.version,
+        serial: system.serial,
+        uuid: system.uuid,
+        sku: system.sku,
+        virtual: system.virtual
+      }
+    };
+
+    logger.verbose('System information collected', {
+      cpuBrand: cpu.brand,
+      totalMemoryGB: (mem.total / (1024 * 1024 * 1024)).toFixed(2),
+      os: `${osInfo.distro} ${osInfo.release}`,
+      graphicsControllers: graphics.controllers?.length || 0,
+      displays: graphics.displays?.length || 0
+    });
+
+    return systemInfo;
+  } catch (error) {
+    logger.error('Failed to collect system information:', {
+      message: error.message,
+      stack: error.stack
+    });
+    
+    // Return minimal system info as fallback
+    return {
+      cpu: { brand: 'Unknown', cores: 0 },
+      mem: { total: 0 },
+      os: { 
+        platform: process.platform,
+        arch: process.arch,
+        release: process.version
+      },
+      graphics: { controllers: [], displays: [] },
+      system: { manufacturer: 'Unknown', model: 'Unknown' }
+    };
+  }
+}

package/lib/tracking/icons/linux.js

@@ -47,6 +47,63 @@ const findLinuxIcon = async (appName) => {
   return null;
 };
 
+/**
+ * Calculate string similarity (Levenshtein distance based)
+ * Returns a value between 0 (no match) and 1 (perfect match)
+ */
+const calculateSimilarity = (str1, str2) => {
+  const s1 = str1.toLowerCase();
+  const s2 = str2.toLowerCase();
+  
+  // Exact match
+  if (s1 === s2) return 1.0;
+  
+  // Check if one contains the other
+  if (s1.includes(s2) || s2.includes(s1)) {
+    return 0.8;
+  }
+  
+  // Simple Levenshtein-based similarity
+  const longer = s1.length > s2.length ? s1 : s2;
+  const shorter = s1.length > s2.length ? s2 : s1;
+  
+  if (longer.length === 0) return 1.0;
+  
+  const editDistance = levenshteinDistance(s1, s2);
+  return (longer.length - editDistance) / longer.length;
+};
+
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+const levenshteinDistance = (str1, str2) => {
+  const matrix = [];
+  
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+  
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+  
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1,     // insertion
+          matrix[i - 1][j] + 1      // deletion
+        );
+      }
+    }
+  }
+  
+  return matrix[str2.length][str1.length];
+};
+
 /**
  * Find .desktop file for an application
  */
@@ -61,11 +118,12 @@ const findDesktopFile = async (appName) => {
   for (const dir of desktopDirs) {
     const desktopFile = path.join(dir, `${appName}.desktop`);
     if (fs.existsSync(desktopFile)) {
+      logger.debug("Found desktop file (exact match)", { appName, desktopFile });
       return desktopFile;
     }
   }
 
-  // Try case-insensitive search
+  // Try case-insensitive exact match
   for (const dir of desktopDirs) {
     try {
       if (!fs.existsSync(dir)) continue;
@@ -75,6 +133,7 @@ const findDesktopFile = async (appName) => {
         (f) => f.toLowerCase() === `${appName.toLowerCase()}.desktop`
       );
       if (match) {
+        logger.debug("Found desktop file (case-insensitive)", { appName, match });
         return path.join(dir, match);
       }
     } catch (error) {
@@ -82,6 +141,40 @@ const findDesktopFile = async (appName) => {
     }
   }
 
+  // Try fuzzy matching - find best match based on string similarity
+  let bestMatch = null;
+  let bestScore = 0.6; // Minimum similarity threshold
+  
+  for (const dir of desktopDirs) {
+    try {
+      if (!fs.existsSync(dir)) continue;
+      
+      const files = fs.readdirSync(dir).filter(f => f.endsWith('.desktop'));
+      
+      for (const file of files) {
+        const baseName = file.replace('.desktop', '');
+        const similarity = calculateSimilarity(appName, baseName);
+        
+        if (similarity > bestScore) {
+          bestScore = similarity;
+          bestMatch = path.join(dir, file);
+        }
+      }
+    } catch (error) {
+      logger.debug("Error in fuzzy desktop file search", { dir, error: error.message });
+    }
+  }
+  
+  if (bestMatch) {
+    logger.debug("Found desktop file (fuzzy match)", { 
+      appName, 
+      desktopFile: bestMatch, 
+      similarity: bestScore.toFixed(2) 
+    });
+    return bestMatch;
+  }
+
+  logger.debug("No desktop file found", { appName });
   return null;
 };
 

package/lib/uploader.js

@@ -5,6 +5,7 @@ import { logger, logFunctionCall } from './logger.js';
 import path from 'path';
 import { auth } from './auth.js';
 import got from 'got';
+import { getSystemInfo } from './systemInfo.js';
 
 class Uploader {
   constructor() {
@@ -200,6 +201,15 @@ export async function upload(filePath, metadata = {}) {
     hasProject: !!metadata.project
   });
 
+  // Collect system information
+  logger.debug('Collecting system information...');
+  const systemInfo = await getSystemInfo();
+  logger.verbose('System information collected for upload', {
+    cpuBrand: systemInfo.cpu?.brand,
+    osDistro: systemInfo.os?.distro,
+    totalMemGB: systemInfo.mem?.total ? (systemInfo.mem.total / (1024 * 1024 * 1024)).toFixed(2) : 'unknown'
+  });
+
   // Handle project ID - use provided project or fetch first available project
   let projectId = metadata.project;
   if (!projectId) {
@@ -229,11 +239,7 @@ export async function upload(filePath, metadata = {}) {
     duration: metadata.duration || 0,
     apps: metadata.apps && metadata.apps.length > 0 ? metadata.apps : ['Screen Recording'], // Use tracked apps or fallback
     title: metadata.title || defaultTitle,
-    system: {
-      platform: process.platform,
-      arch: process.arch,
-      nodeVersion: process.version
-    },
+    system: systemInfo, // Include system information
     clientStartDate: metadata.clientStartDate || Date.now() // Use actual recording start time
   };
 
@@ -255,7 +261,7 @@ export async function upload(filePath, metadata = {}) {
   
   let newReplay;
   try {
-    newReplay = await got.post('https://api.testdriver.ai/api/v1/replay', {
+    newReplay = await got.post('https://testdriver-api.onrender.com/api/v1/replay', {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -430,7 +436,7 @@ export async function upload(filePath, metadata = {}) {
 
   // Publish the replay (like the desktop app does)
   logger.debug('Publishing replay...');
-  await got.post('https://api.testdriver.ai/api/v1/replay/publish', {
+  await got.post('https://testdriver-api.onrender.com/api/v1/replay/publish', {
     headers: {
       Authorization: `Bearer ${token}`
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.0.1-beta.23",
+  "version": "1.0.1-beta.25",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/index.js",
   "bin": {
@@ -47,6 +47,7 @@
     "mask-sensitive-data": "^0.11.5",
     "node-fetch": "^2.7.0",
     "open": "^9.1.0",
+    "systeminformation": "^5.18.15",
     "tail": "^2.2.6",
     "winston": "^3.11.0",
     "ws": "^8.18.3"