dashcam 0.8.4 → 1.0.1-beta.10

package/lib/store.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+import { APP } from './config.js';
+import { logger } from './logger.js';
+
+class Store {
+  constructor(filename) {
+    this.path = path.join(APP.configDir, `${filename}.json`);
+    this.data = this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.path)) {
+        const data = fs.readFileSync(this.path, 'utf8');
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      logger.error('Failed to load store:', error);
+    }
+    return {};
+  }
+
+  save() {
+    try {
+      // Ensure directory exists
+      fs.mkdirSync(path.dirname(this.path), { recursive: true });
+      fs.writeFileSync(this.path, JSON.stringify(this.data, null, 2));
+    } catch (error) {
+      logger.error('Failed to save store:', error);
+    }
+  }
+
+  get(key) {
+    return this.data[key];
+  }
+
+  set(key, value) {
+    this.data[key] = value;
+    this.save();
+  }
+
+  delete(key) {
+    delete this.data[key];
+    this.save();
+  }
+
+  has(key) {
+    return key in this.data;
+  }
+
+  clear() {
+    this.data = {};
+    this.save();
+  }
+}
+
+export { Store };

package/lib/tracking/FileTracker.js

@@ -0,0 +1,105 @@
+import { Tail } from 'tail';
+import { logger } from '../logger.js';
+import fs from 'fs';
+
+// Simple function to get stats for events in the last minute
+function getStats(eventTimes = []) {
+  const endTime = Date.now();
+  const startTime = Date.now() - 60000;
+
+  let startIndex = 0;
+  let count = 0;
+
+  for (const time of eventTimes) {
+    if (time < startTime) startIndex++;
+    else if (time <= endTime) {
+      count++;
+    } else break;
+  }
+
+  return {
+    eventTimes: eventTimes.slice(startIndex),
+    count,
+  };
+}
+
+// Simple ANSI escape code regex for stripping colors
+const ansiRegex = /[\u001B\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d\\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g;
+
+function stripAnsi(string) {
+  if (typeof string !== 'string') {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(ansiRegex, '');
+}
+
+export class FileTracker {
+  constructor(trackedFile, callback) {
+    this.tail = null;
+    this.eventTimes = [];
+    this.callback = callback;
+    this.trackedFile = trackedFile;
+
+    try {
+      // Ensure the file exists before creating the Tail watcher
+      if (!fs.existsSync(this.trackedFile)) {
+        logger.warn(`File does not exist, creating: ${this.trackedFile}`);
+        fs.writeFileSync(this.trackedFile, '', 'utf8');
+      }
+      
+      this.tail = new Tail(this.trackedFile, { encoding: 'ascii' });
+      this.tail.on('line', (line) => {
+        const time = Date.now();
+        this.eventTimes.push(time);
+
+        // Log errors for debugging (simplified error handling)
+        if (line.toLowerCase().indexOf('error') > -1) {
+          logger.warn('Error found in log file', { 
+            file: trackedFile, 
+            line: stripAnsi(line).substring(0, 200) 
+          });
+        }
+
+        if (!this.callback) return;
+
+        try {
+          this.callback({
+            line,
+            time,
+            logFile: this.trackedFile,
+          });
+        } catch (err) {
+          logger.error(
+            `FAILED callback for FileTracker ${this.trackedFile} with error:`,
+            err
+          );
+        }
+      });
+
+      this.tail.on('error', (data) => {
+        logger.error(
+          `Error in file tracker for file "${this.trackedFile}": ${data}`
+        );
+      });
+    } catch (e) {
+      logger.error('Failed to create FileTracker', { trackedFile, error: e });
+    }
+  }
+
+  destroy() {
+    if (this.tail) {
+      this.tail.unwatch();
+      this.tail = null;
+    }
+  }
+
+  getStats() {
+    const { eventTimes, count } = getStats(this.eventTimes);
+
+    this.eventTimes = eventTimes;
+    return {
+      count,
+      item: this.trackedFile,
+    };
+  }
+}

package/lib/tracking/FileTrackerManager.js

@@ -0,0 +1,62 @@
+import { logger } from '../logger.js';
+import { FileTracker } from './FileTracker.js';
+
+export class FileTrackerManager {
+  constructor() {
+    this.byFilePath = {};
+  }
+
+  getStats(filePath) {
+    if (!this.byFilePath[filePath]) {
+      return { item: filePath, count: 0 };
+    }
+    return this.byFilePath[filePath].tracker.getStats();
+  }
+
+  subscribe(filePath, callback) {
+    if (!this.byFilePath[filePath]) {
+      this.byFilePath[filePath] = {
+        callbacks: [],
+        tracker: new FileTracker(filePath, (event) => {
+          this.#sendEvent(filePath, event);
+        })
+      };
+    }
+    this.byFilePath[filePath].callbacks.push(callback);
+    return () => this.unsubscribe(filePath, callback);
+  }
+
+  unsubscribe(filePath, callback) {
+    if (!this.byFilePath[filePath]) return;
+    
+    this.byFilePath[filePath].callbacks = this.byFilePath[filePath].callbacks
+      .filter(cb => cb !== callback);
+
+    if (this.byFilePath[filePath].callbacks.length === 0) {
+      this.byFilePath[filePath].tracker.destroy();
+      delete this.byFilePath[filePath];
+    }
+  }
+
+  #sendEvent(filePath, event) {
+    if (!this.byFilePath[filePath]) return;
+
+    for (const callback of this.byFilePath[filePath].callbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        logger.error(
+          "Failed sending FileTracker event",
+          { event, filePath, error }
+        );
+      }
+    }
+  }
+
+  destroy() {
+    for (const filePath of Object.keys(this.byFilePath)) {
+      this.byFilePath[filePath].tracker.destroy();
+    }
+    this.byFilePath = {};
+  }
+}

package/lib/tracking/LogsTracker.js

@@ -0,0 +1,161 @@
+import path from 'path';
+import { logger } from '../logger.js';
+import { FileTrackerManager } from './FileTrackerManager.js';
+import { jsonl } from '../utilities/jsonl.js';
+
+export class LogsTracker {
+  // Omitting a directory puts it in a watch only mode where it
+  // only collect per minute stats
+  constructor({ config = {}, directory, fileTrackerManager }) {
+    this.files = {};
+    this.fileIndex = 0;
+    this.fileToIndex = {};
+    this.config = config;
+    this.isWatchOnly = !directory;
+    this.fileTrackerManager = fileTrackerManager || new FileTrackerManager();
+    
+    const filename = 'dashcam_logs_cli.jsonl';
+    this.fileLocation = this.isWatchOnly ? '' : path.join(directory, filename);
+    
+    // Start tracking files from initial config
+    this._updateTrackedFiles();
+  }
+
+  updateConfig(config) {
+    this.config = config;
+    this._updateTrackedFiles();
+  }
+
+  _updateTrackedFiles() {
+    const updatedFilePaths = Object.keys(this.config);
+    updatedFilePaths.forEach((filePath) => this._startFileTracker(filePath));
+
+    Object.keys(this.files)
+      .filter((filePath) => !updatedFilePaths.includes(filePath))
+      .forEach((filePath) => this._stopFileTracker(filePath));
+  }
+
+  _startFileTracker(filePath) {
+    if (this.files[filePath]) return;
+
+    const index = ++this.fileIndex;
+    this.fileToIndex[filePath] = index;
+    const status = {
+      item: index,
+      count: 0,
+    };
+    const callback = (event) => {
+      if (!this.fileLocation) return;
+      jsonl.append(this.fileLocation, {
+        ...event,
+        logFile: filePath,
+      });
+      status.count++;
+    };
+
+    this.files[filePath] = {
+      status,
+      filePath, // Store file path for later reference
+      unsubscribe: this.fileTrackerManager.subscribe(filePath, callback),
+    };
+    
+    logger.info(`Started tracking logs for ${filePath}`);
+  }
+
+  _stopFileTracker(filePath) {
+    const unsubscribe = this.files[filePath]?.unsubscribe;
+    if (unsubscribe) {
+      delete this.fileToIndex[filePath];
+      unsubscribe();
+      delete this.files[filePath];
+      logger.info(`Stopped tracking logs for ${filePath}`);
+    }
+  }
+
+  // Legacy methods for backwards compatibility
+  startTracking(filePath) {
+    if (!this.config[filePath]) {
+      this.config[filePath] = true;
+      this._updateTrackedFiles();
+    }
+  }
+
+  stopTracking(filePath) {
+    if (this.config[filePath]) {
+      delete this.config[filePath];
+      this._updateTrackedFiles();
+    }
+  }
+
+  startRecording(recordingPath) {
+    this.fileLocation = recordingPath;
+    logger.info(`Started recording to ${recordingPath}`);
+  }
+
+  stopRecording() {
+    this.fileLocation = null;
+    logger.info('Stopped recording');
+  }
+
+  getStatus() {
+    let items = [];
+    let filePathMap = {};
+    
+    if (this.isWatchOnly) {
+      items = Object.keys(this.files).map((filePath) => {
+        const index = this.fileToIndex[filePath];
+        filePathMap[index] = filePath;
+        return {
+          ...this.fileTrackerManager.getStats(filePath),
+          item: index, // Keep numeric index to match events
+        };
+      });
+    } else {
+      items = Object.values(this.files).map(({ status, filePath }) => {
+        const index = status.item;
+        filePathMap[index] = filePath;
+        return {
+          ...status,
+        };
+      });
+    }
+
+    const totalCount = items.reduce((acc, status) => acc + status.count, 0);
+
+    return [
+      {
+        id: 'CLI',
+        name: 'File Logs', // More descriptive name
+        type: 'cli',
+        fileLocation: this.fileLocation,
+        items: items,
+        count: totalCount,
+        filePathMap: filePathMap, // Include mapping for UI to display file paths
+      },
+    ];
+  }
+
+  // Legacy method for backwards compatibility
+  getStats() {
+    const status = this.getStatus();
+    return status.length > 0 ? status[0] : {
+      id: 'CLI',
+      name: 'File Logs', 
+      type: 'cli',
+      fileLocation: this.fileLocation,
+      items: [],
+      count: 0
+    };
+  }
+
+  destroy() {
+    const status = this.getStatus();
+    for (const filePath of Object.keys(this.files)) {
+      this._stopFileTracker(filePath);
+    }
+    this.fileTrackerManager.destroy();
+    this.fileLocation = null;
+    logger.info('Destroyed log tracker');
+    return status;
+  }
+}

package/lib/tracking/active-win.js

@@ -0,0 +1,212 @@
+const _ = require("lodash");
+const path = require("path");
+const fs = require("fs");
+const { logger, logFunctionCall } = require("../logger.js");
+const { extractIcon } = require("./icons");
+
+// Try to load get-windows, but handle gracefully if it's not available (e.g., in pkg builds)
+let activeWindowSync = null;
+
+try {
+  const getWindows = require("get-windows");
+  activeWindowSync = getWindows.activeWindowSync;
+  logger.debug("Successfully loaded get-windows module");
+} catch (error) {
+  logger.debug("get-windows not available, application tracking will be disabled");
+}
+
+const normalizeAppName = (name) => {
+  name = name.split(".exe")[0];
+  name = name.toLowerCase();
+  return name;
+};
+
+// Simple JSONL utilities for CLI
+const jsonl = {
+  append: (filePath, data) => {
+    const line = JSON.stringify(data) + '\n';
+    fs.appendFileSync(filePath, line);
+  }
+};
+
+class ActiveWin {
+  constructor({ recorderId, screenId, directory, fileName }) {
+    this.recorderId = recorderId;
+    this.screenId = screenId;
+    this.directory = directory;
+    this.fileName = fileName;
+
+    this.intervalRef = null;
+    this.failedAttempts = 0;
+  }
+
+  async trackActiveWin() {
+    if (this.failedAttempts === 5) {
+      logger.warn("active-win.js failed 5 attempts, stopping interval", {
+        recorderId: this.recorderId,
+        screenId: this.screenId,
+      });
+      this.stop();
+      return;
+    }
+
+    try {
+      let awin = null;
+      
+      // Try native module
+      if (activeWindowSync) {
+        awin = activeWindowSync();
+      } else {
+        // No tracking method available
+        if (this.failedAttempts === 0) {
+          logger.debug("Active window tracking unavailable (get-windows not available)");
+        }
+        this.failedAttempts = 5;
+        this.stop();
+        return;
+      }
+
+      if (awin) {
+        const result = {
+          title: awin.title,
+          time: Date.now(),
+          owner: {
+            id: awin.owner?.bundleId || awin.owner?.path,
+            name: normalizeAppName(awin.owner?.name),
+          },
+        };
+
+        // Extract icon for this application
+        await extractIcon({ name: result.owner.name, id: result.owner.id });
+
+        // Write to JSONL file
+        jsonl.append(path.join(this.directory, this.fileName), result);
+        
+        logger.silly("Tracked active window", {
+          app: result.owner.name,
+          title: result.title?.substring(0, 50)
+        });
+      } else {
+        logger.debug("active-win.js activeWindowSync() returned nullable value");
+        this.failedAttempts++;
+      }
+    } catch (err) {
+      logger.warn("active-win.js error", {
+        error: err.message,
+        attempt: this.failedAttempts + 1
+      });
+      this.failedAttempts++;
+    }
+  }
+
+  start() {
+    const logExit = logFunctionCall('ActiveWin.start');
+    
+    logger.debug("active-win.js starting tracking active win", {
+      recorderId: this.recorderId,
+      screenId: this.screenId,
+      directory: this.directory,
+      fileName: this.fileName,
+    });
+
+    if (!this.screenId || !this.directory || !this.fileName) {
+      logger.warn("active-win.js missing args", {
+        recorderId: this.recorderId,
+        screenId: this.screenId,
+      });
+      logExit();
+      return;
+    }
+
+    if (!this.intervalRef) {
+      logger.debug("active-win.js active win start interval");
+      this.intervalRef = setInterval(() => this.trackActiveWin(), 10000);
+    } else {
+      logger.debug("active-win.js active win already started", {
+        recorderId: this.recorderId,
+        screenId: this.screenId,
+      });
+    }
+    
+    logExit();
+  }
+
+  stop = () => {
+    const logExit = logFunctionCall('ActiveWin.stop');
+    
+    logger.debug("active-win.js removing tracker for screen", {
+      recorderId: this.recorderId,
+      screenId: this.screenId,
+    });
+
+    if (this.intervalRef) {
+      clearInterval(this.intervalRef);
+    }
+
+    this.intervalRef = null;
+    logExit();
+  };
+}
+
+class ActiveWinManager {
+  constructor() {
+    this.activeWins = [];
+  }
+
+  startNew({ recorderId, screenId, directory, fileName }) {
+    const logExit = logFunctionCall('ActiveWinManager.startNew');
+    
+    const activeWin = new ActiveWin({
+      recorderId,
+      screenId,
+      directory,
+      fileName,
+    });
+
+    activeWin.start();
+    this.activeWins.push(activeWin);
+    
+    logger.debug("Started new active window tracker", {
+      recorderId,
+      screenId,
+      totalTrackers: this.activeWins.length
+    });
+    
+    logExit();
+  }
+
+  stop({ recorderId, screenId }) {
+    const logExit = logFunctionCall('ActiveWinManager.stop');
+    
+    const index = this.activeWins.findIndex(
+      (win) => win.recorderId === recorderId && win.screenId === screenId
+    );
+
+    if (index > -1) {
+      const activeWin = this.activeWins[index];
+      activeWin.stop();
+      this.activeWins.splice(index, 1);
+      
+      logger.debug("Stopped active window tracker", {
+        recorderId,
+        screenId,
+        remainingTrackers: this.activeWins.length
+      });
+    }
+    
+    logExit();
+  }
+
+  stopAll() {
+    const logExit = logFunctionCall('ActiveWinManager.stopAll');
+    
+    logger.info("active-win.js stopping all active wins");
+    this.activeWins.forEach((activeWin) => activeWin.stop());
+    this.activeWins = [];
+    
+    logExit();
+  }
+}
+
+const activeWinManager = new ActiveWinManager();
+module.exports = activeWinManager;

package/lib/tracking/icons/darwin.js

@@ -0,0 +1,39 @@
+import { logger } from "../../logger.js";
+
+const getIconAsBuffer = async (bundleId) => {
+  try {
+    // Try to import the file-icon package for macOS icon extraction
+    // This may fail in pkg builds where native modules don't work
+    const { fileIconToBuffer } = await import("file-icon");
+
+    logger.debug("Extracting icon for macOS app", { bundleId });
+    
+    const buffer = await fileIconToBuffer(bundleId);
+    if (!buffer) {
+      logger.debug("No icon buffer returned for bundle", { bundleId });
+      return null;
+    }
+    
+    logger.debug("Successfully extracted macOS icon", { 
+      bundleId, 
+      bufferSize: buffer.length 
+    });
+    
+    return { extension: "png", buffer };
+  } catch (error) {
+    // Don't log warnings for module loading errors in pkg builds
+    if (error.code === 'MODULE_NOT_FOUND' || error.message.includes('Dynamic require')) {
+      logger.debug("Icon extraction unavailable (native module not loaded)", {
+        isPkg: typeof process.pkg !== 'undefined'
+      });
+    } else {
+      logger.warn("Failed to extract macOS icon", { 
+        bundleId, 
+        error: error.message 
+      });
+    }
+    return null;
+  }
+};
+
+export { getIconAsBuffer };