dashcam 0.8.4 → 1.0.1-beta.10

package/lib/auth.js

@@ -0,0 +1,222 @@
+import got from 'got';
+import { auth0Config } from './config.js';
+import { logger, logFunctionCall } from './logger.js';
+import { Store } from './store.js';
+
+const tokenStore = new Store('auth0-store');
+const TOKEN_KEY = 'tokens';
+
+const auth = {
+  async login(apiKey) {
+    const logExit = logFunctionCall('auth.login');
+    
+    try {
+      logger.info('Authenticating with API key');
+      logger.verbose('Starting API key exchange', {
+        apiKeyLength: apiKey?.length,
+        hasApiKey: !!apiKey
+      });
+      
+      // Exchange API key for token
+      const { token } = await got.post('https://api.testdriver.ai/auth/exchange-api-key', {
+        json: { apiKey },
+        timeout: 30000 // 30 second timeout
+      }).json();
+
+      if (!token) {
+        throw new Error('Failed to exchange API key for token');
+      }
+
+      logger.verbose('Successfully exchanged API key for token', {
+        tokenLength: token.length,
+        tokenPrefix: token.substring(0, 10) + '...'
+      });
+
+      // 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', {
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        timeout: 30000
+      }).json();
+
+      logger.verbose('User information retrieved', {
+        userId: user.id,
+        userEmail: user.email || 'not provided',
+        userName: user.name || 'not provided'
+      });
+
+      // Store both token and user info
+      const tokenData = {
+        token,
+        user,
+        expires_at: Date.now() + (24 * 60 * 60 * 1000) // 24 hours
+      };
+      
+      tokenStore.set(TOKEN_KEY, tokenData);
+
+      logger.info('Successfully authenticated and stored token', {
+        expiresAt: new Date(tokenData.expires_at).toISOString(),
+        userId: user.id
+      });
+      
+      logExit();
+      return token;
+
+    } catch (error) {
+      logger.error('Authentication failed:', {
+        message: error.message,
+        statusCode: error.response?.statusCode,
+        responseBody: error.response?.body
+      });
+      logExit();
+      throw error;
+    }
+  },
+
+  async logout() {
+    try {
+      tokenStore.delete(TOKEN_KEY);
+      logger.info('Successfully logged out');
+    } catch (error) {
+      logger.error('Failed to logout:', error);
+      throw error;
+    }
+  },
+
+  async getToken() {
+    const tokens = tokenStore.get(TOKEN_KEY);
+    if (!tokens || Date.now() >= tokens.expires_at) {
+      throw new Error('No valid token found. Please login with an API key first');
+    }
+    return tokens.token;
+  },
+
+  async isAuthenticated() {
+    const tokens = tokenStore.get(TOKEN_KEY);
+    return tokens && tokens.expires_at && Date.now() < tokens.expires_at;
+  },
+
+  async getProjects() {
+    const logExit = logFunctionCall('auth.getProjects');
+    
+    logger.debug('Fetching user projects...');
+    const token = await this.getToken();
+    
+    try {
+      const response = await got.get('https://api.testdriver.ai/api/v1/projects', {
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        timeout: 30000
+      }).json();
+      
+      logger.verbose('Projects fetched successfully', {
+        projectCount: response.length
+      });
+      
+      logExit();
+      return response;
+    } catch (error) {
+      logger.error('Failed to fetch projects:', {
+        message: error.message,
+        statusCode: error.response?.statusCode
+      });
+      logExit();
+      throw error;
+    }
+  },
+
+  async getStsCredentials(replayData = {}) {
+    const logExit = logFunctionCall('auth.getStsCredentials');
+    
+    logger.debug('Fetching STS credentials for upload...');
+    const token = await this.getToken();
+    
+    logger.verbose('Making STS request', {
+      tokenPrefix: token.substring(0, 10) + '...',
+      replayData: {
+        id: replayData.id,
+        duration: replayData.duration,
+        title: replayData.title,
+        hasApps: !!replayData.apps,
+        hasIcons: !!replayData.icons,
+        hasProject: !!replayData.project
+      }
+    });
+    
+    // Prepare the request body to match the desktop app
+    const requestBody = {
+      id: replayData.id,
+      duration: replayData.duration || 0,
+      apps: replayData.apps || [],
+      title: replayData.title || 'CLI Recording',
+      icons: replayData.icons || []
+    };
+
+    // Include project if provided
+    if (replayData.project) {
+      requestBody.project = replayData.project;
+    }
+    
+    const response = await got.post('https://api.testdriver.ai/api/v1/replay/upload', {
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      json: requestBody,
+      timeout: 30000
+    }).json();
+    
+    logger.verbose('STS response received', {
+      hasVideo: !!response.video,
+      hasGif: !!response.gif,
+      hasImage: !!response.image,
+      hasIcons: !!response.icons
+    });
+
+    // The API returns separate STS credentials for video, gif, and image
+    // Each contains: accessKeyId, secretAccessKey, sessionToken, bucket, region, file
+    logExit();
+    return response;
+  },
+
+  async createLogSts(replayId, appId, name, type) {
+    const logExit = logFunctionCall('auth.createLogSts');
+    
+    logger.debug('Creating log STS credentials', { replayId, appId, name, type });
+    const token = await this.getToken();
+    
+    try {
+      const response = await got.post('https://api.testdriver.ai/api/v1/logs', {
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        json: {
+          replayId,
+          appId,
+          name,
+          type
+        },
+        timeout: 30000
+      }).json();
+      
+      logger.verbose('Log STS credentials created', {
+        logId: response.id,
+        hasCredentials: !!response.bucket
+      });
+      
+      logExit();
+      return response;
+    } catch (error) {
+      logger.error('Failed to create log STS credentials:', {
+        message: error.message,
+        statusCode: error.response?.statusCode
+      });
+      logExit();
+      throw error;
+    } // Return the full response with video, gif, image objects
+  }
+};
+
+export { auth };

package/lib/binaries.js

@@ -0,0 +1,21 @@
+import ffmpegStatic from 'ffmpeg-static';
+import ffprobeStatic from 'ffprobe-static';
+import { logger } from './logger.js';
+
+/**
+ * Get the path to the ffmpeg binary
+ * @returns {Promise<string>} Path to ffmpeg
+ */
+export async function getFfmpegPath() {
+  logger.debug('Getting ffmpeg path from ffmpeg-static', { path: ffmpegStatic });
+  return ffmpegStatic;
+}
+
+/**
+ * Get the path to the ffprobe binary
+ * @returns {Promise<string>} Path to ffprobe
+ */
+export async function getFfprobePath() {
+  logger.debug('Getting ffprobe path from ffprobe-static', { path: ffprobeStatic.path });
+  return ffprobeStatic.path;
+}

package/lib/config.js

@@ -0,0 +1,34 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const ENV = process.env.NODE_ENV || 'production';
+
+export const auth0Config = {
+  domain: 'replayable.us.auth0.com',
+  clientId: 'aYo59XVgKhhfrY9lFb35quLdMtF2j6WJ',
+  audience: 'https://replayable.us.auth0.com/api/v2/',
+  scopes: 'given_name profile email offline_access',
+};
+
+export const apiEndpoints = {
+  development: process.env.API_ENDPOINT || 'http://localhost:3000',
+  staging: 'https://replayable-api-staging.herokuapp.com',
+  production: 'https://api.testdriver.ai'
+};
+
+export const API_ENDPOINT = apiEndpoints[ENV];
+
+// App configuration
+export const APP = {
+  id: 'dashcam-cli',
+  name: ENV === 'production' ? 'Dashcam CLI' : `Dashcam CLI - ${ENV}`,
+  version: process.env.npm_package_version || '1.0.0',
+  configDir: join(homedir(), '.dashcam'),
+  logsDir: join(homedir(), '.dashcam', 'logs'),
+  recordingsDir: join(homedir(), '.dashcam', 'recordings'),
+  minRecordingDuration: 3000 // 3 seconds, matching desktop
+};

package/lib/extension-logs/helpers.js

@@ -0,0 +1,182 @@
+import maskSensitiveData from 'mask-sensitive-data';
+
+const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+
+const shouldCountEvent = (eventType) => {
+  return ['LOG_ERROR', 'LOG_EVENT', 'NETWORK_BEFORE_REQUEST'].includes(
+    eventType
+  );
+};
+
+const eventTypeToStatType = {
+  LOG_EVENT: 'logs',
+  LOG_ERROR: 'errors',
+  NETWORK_BEFORE_REQUEST: 'network',
+};
+
+const verifyPattern = (pattern, str = '') => {
+  if (typeof pattern !== 'string' || typeof str !== 'string')
+    throw new Error(
+      `verifyPattern expects two string arguments but instead got "pattern" of type ${typeof pattern} and "str" of type ${typeof str}`
+    );
+  return new RegExp(
+    '^' + pattern.split('*').map(escapeRegExp).join('.*'),
+    'i'
+  ).test(str);
+};
+
+const updateTabsState = (event, tabs) => {
+  const { type, payload } = event;
+  switch (type) {
+    case 'INITIAL_TABS':
+      tabs = payload.reduce((tabs, tab) => {
+        if (tab.url) tabs[tab.tabId] = { ...tab, previousUrl: '' };
+        return tabs;
+      }, {});
+      break;
+    case 'TAB_REMOVED':
+      delete tabs[payload.tabId];
+      break;
+    case 'TAB_ACTIVATED':
+      tabs[payload.tabId] ??= payload;
+    case 'NAVIGATION_STARTED':
+    case 'NAVIGATION_COMPLETED':
+      if (tabs[payload.tabId] && tabs[payload.tabId].url !== payload.url) {
+        tabs[payload.tabId].previousUrl = tabs[payload.tabId].url;
+        tabs[payload.tabId].url = payload.url;
+      }
+      break;
+    default:
+      if (tabs[payload.tabId]) tabs[payload.tabId].previousUrl = '';
+  }
+
+  return tabs;
+};
+
+function sanitizeWebLogEventPayload(obj) {
+  let result = obj;
+  if (obj === null || obj === undefined) {
+  } else if (typeof obj === 'string')
+    result = maskSensitiveData.default(obj, {
+      ...maskSensitiveData.defaultMaskOptions,
+      jwtPattern: /\b(?:[A-Za-z0-9\-_=]{40,}|[A-Fa-f0-9\-_=]{40,})\b/g,
+    });
+  else if (Array.isArray(obj)) {
+    result = obj.map((element) => sanitizeWebLogEventPayload(element));
+  } else if (typeof obj === 'object') {
+    result = Object.entries(obj).reduce((result, [key, value]) => {
+      if (!key.toLowerCase().includes('url'))
+        result[key] = sanitizeWebLogEventPayload(value);
+      else result[key] = value;
+      return result;
+    }, {});
+  }
+  return result;
+}
+
+function filterWebEvents(
+  events,
+  groupLogsStatuses,
+  startMs = events[0]?.time ?? 0,
+  endMs = events[events.length - 1]?.time ?? 0
+) {
+  const tempEvents = events.filter(
+    event => event.type === 'INITIAL_TABS' || event.payload.tabId
+  );
+  const patterns = groupLogsStatuses
+    .map((status) => status.items.map((item) => item.item))
+    .flat();
+
+  const newEvents = [];
+  let tabs = {};
+  let tracked;
+  let map = {};
+
+  tempEvents
+    .filter((event) => event.time <= startMs)
+    .forEach((event) => (tabs = updateTabsState(event, tabs)));
+
+  tempEvents.push({
+    type: 'INITIAL_TABS',
+    time: startMs,
+    payload: Object.values(tabs).map(({ previousUrl, ...tab }) => tab),
+  });
+
+  for (const event of tempEvents.filter(
+    (event) => event.time >= startMs && event.time <= endMs
+  )) {
+    try {
+      switch (event.type) {
+        case 'NAVIGATION_STARTED':
+        case 'NAVIGATION_COMPLETED':
+          tracked = patterns.some((pattern) =>
+            verifyPattern(pattern, event.payload.url)
+          );
+          if (tracked) newEvents.push(event);
+          map[event.payload.tabId] = event.payload.url;
+          break;
+
+        case 'NETWORK_BEFORE_REQUEST':
+          tracked = patterns.some((pattern) =>
+            verifyPattern(pattern, map[event.payload.tabId])
+          );
+          if (tracked) newEvents.push(event);
+          break;
+
+        case 'NETWORK_COMPLETED_REQUEST':
+        case 'NETWORK_ERROR_REQUEST':
+          const startedEvent = newEvents.find(
+            (e) =>
+              e.payload.requestId === event.payload.requestId &&
+              e.type === 'NETWORK_BEFORE_REQUEST'
+          );
+          if (startedEvent) newEvents.push(event);
+          break;
+
+        case 'NETWORK_RESPONSE_BODY':
+          const completedEvent = newEvents.find(
+            (e) =>
+              e.payload.requestId === event.payload.requestId &&
+              e.type === 'NETWORK_COMPLETED_REQUEST'
+          );
+          if (completedEvent) newEvents.push(event);
+          break;
+
+        case 'LOG_ERROR':
+        case 'LOG_EVENT':
+        case 'SPA_NAVIGATION':
+          tracked = patterns.some((pattern) =>
+            verifyPattern(pattern, map[event.payload.tabId])
+          );
+          if (tracked) newEvents.push(event);
+          break;
+
+        case 'TAB_ACTIVATED':
+          tracked = patterns.some((pattern) =>
+            verifyPattern(pattern, event.payload.url)
+          );
+          if (tracked) {
+            map[event.payload.tabId] = event.payload.url;
+            newEvents.push(event);
+          }
+          break;
+          
+        case 'INITIAL_TABS':
+          newEvents.push(event);
+          break;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+  }
+  return newEvents;
+}
+
+export {
+  verifyPattern,
+  updateTabsState,
+  filterWebEvents,
+  shouldCountEvent,
+  eventTypeToStatType,
+  sanitizeWebLogEventPayload,
+};