dashcam 0.8.4 → 1.0.1-beta.11

package/lib/tracking/icons/index.js

@@ -0,0 +1,167 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { logger } from "../../logger.js";
+
+// For CLI, we'll use a simple platform detection
+const PLATFORM = process.platform;
+
+// Import platform-specific icon extractors lazily
+let getIconAsBuffer;
+let iconModuleLoaded = false;
+
+async function ensureIconModule() {
+  if (iconModuleLoaded) return;
+  
+  if (PLATFORM === "darwin") {
+    const darwinModule = await import("./darwin.js");
+    getIconAsBuffer = darwinModule.getIconAsBuffer;
+  } else if (PLATFORM === "win32") {
+    const windowsModule = await import("./windows.js");
+    getIconAsBuffer = windowsModule.getIconAsBuffer;
+  } else {
+    // Linux fallback
+    getIconAsBuffer = () => null;
+  }
+  
+  iconModuleLoaded = true;
+}
+
+class IconCache {
+  constructor(folderPath) {
+    this.folderPath = folderPath;
+
+    // Ensure the icons directory exists
+    if (!fs.existsSync(this.folderPath)) {
+      fs.mkdirSync(this.folderPath, { recursive: true });
+    }
+
+    this.icons = {};
+    
+    try {
+      const files = fs.readdirSync(this.folderPath);
+      files.forEach((file) => {
+        let extension;
+        if (file.endsWith(".png")) extension = "png";
+        else if (file.endsWith(".ico")) extension = "ico";
+        else return;
+
+        // We use replace instead of split because for mac we use bundle ids which have dots in them
+        const id = file.replace(".png", "").replace(".ico", "");
+
+        this.icons[id] = { extension };
+      });
+      
+      logger.debug("IconCache initialized", { 
+        folderPath: this.folderPath,
+        cachedIcons: Object.keys(this.icons).length 
+      });
+    } catch (error) {
+      logger.warn("Failed to initialize IconCache", { 
+        folderPath: this.folderPath,
+        error: error.message 
+      });
+    }
+  }
+
+  has(id) {
+    return this.icons[id];
+  }
+
+  set(name, { extension, buffer }) {
+    const id = idFromName(name);
+    try {
+      const filePath = path.join(this.folderPath, `${id}.${extension}`);
+      fs.writeFileSync(filePath, buffer);
+      this.icons[id] = { extension };
+      
+      logger.debug("Icon cached", { name, id, extension, filePath });
+    } catch (e) {
+      logger.error(`IconCache: error writing icon for ${id}`, { error: e.message });
+    }
+  }
+
+  get(name) {
+    const id = idFromName(name);
+
+    if (!this.icons[id]) {
+      logger.debug(`IconCache: no icon for ${id}`);
+      return null;
+    }
+
+    const { extension } = this.icons[id];
+    const filePath = path.join(this.folderPath, `${id}.${extension}`);
+
+    try {
+      return {
+        normalizedName: name,
+        extension,
+        file: filePath,
+        buffer: fs.readFileSync(filePath),
+      };
+    } catch (error) {
+      logger.error(`IconCache: error reading icon for ${id}`, { error: error.message });
+      return null;
+    }
+  }
+}
+
+// Create icons directory in CLI temp folder
+const iconsDir = path.join(os.tmpdir(), 'dashcam-cli-icons');
+const iconCache = new IconCache(iconsDir);
+
+const idFromName = (name) => name.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+
+const extractIcon = async ({ name, id }) => {
+  if (!name) {
+    logger.debug("extractIcon: no name provided");
+    return;
+  }
+
+  const normalizedId = idFromName(name);
+  
+  if (!iconCache.has(normalizedId)) {
+    if (!id) {
+      logger.debug(`extractIcon: no id for ${name}`);
+      return;
+    }
+    
+    try {
+      // Ensure the icon module is loaded before using it
+      await ensureIconModule();
+      
+      const result = await getIconAsBuffer(id);
+      if (!result) {
+        logger.debug(`extractIcon: no icon buffer returned for ${name} (${id})`);
+        return;
+      }
+
+      iconCache.set(name, {
+        extension: result.extension,
+        buffer: result.buffer,
+      });
+      
+      logger.debug("Icon extracted and cached", { name, id, extension: result.extension });
+    } catch (error) {
+      logger.warn("Failed to extract icon", { name, id, error: error.message });
+    }
+  } else {
+    logger.silly("Icon already cached", { name });
+  }
+};
+
+const getIconData = (name, withBase64 = false) => {
+  const iconData = iconCache.get(name);
+  if (!iconData) return null;
+
+  return {
+    extension: iconData.extension,
+    file: iconData.file,
+    base64:
+      iconData.buffer && withBase64
+        ? "data:image/" + iconData.extension + ";base64," + iconData.buffer.toString("base64")
+        : null,
+  };
+};
+
+export { extractIcon, getIconData, iconCache };

package/lib/tracking/icons/windows.js

@@ -0,0 +1,27 @@
+import { logger } from "../../logger.js";
+
+const getIconAsBuffer = async (exePath) => {
+  try {
+    // For CLI on Windows, we'll need a different approach since we don't have Electron
+    // We could use a package like 'extract-file-icon' or similar
+    // For now, we'll return null and log that Windows icon extraction is not implemented
+    
+    logger.debug("Windows icon extraction not implemented in CLI", { exePath });
+    
+    // TODO: Implement Windows icon extraction using a CLI-compatible library
+    // Potential options:
+    // - extract-file-icon package
+    // - Windows API calls via FFI
+    // - PowerShell script execution
+    
+    return null;
+  } catch (error) {
+    logger.warn("Failed to extract Windows icon", { 
+      exePath, 
+      error: error.message 
+    });
+    return null;
+  }
+};
+
+export { getIconAsBuffer };

package/lib/tracking/idle.js

@@ -0,0 +1,82 @@
+const { logger, logFunctionCall } = require("../logger.js");
+
+// Simple idle tracker for CLI (without Electron powerMonitor)
+// This is a simplified version that doesn't track system idle time
+// since that requires platform-specific system calls
+
+class IdleTracker {
+  constructor() {
+    this.stopped = true;
+    this.interval = null;
+    this.callbacks = [];
+  }
+
+  start() {
+    const logExit = logFunctionCall('IdleTracker.start');
+    
+    logger.debug("idle.js starting idle tracker");
+
+    if (this.stopped) {
+      // For CLI, we'll just emit 0 idle time since we don't have system access
+      // This could be enhanced with platform-specific idle detection in the future
+      this.interval = setInterval(() => {
+        if (!this.stopped) {
+          // Always report 0 idle time for CLI
+          const idleTimeMs = 0;
+          
+          // Call any registered callbacks
+          this.callbacks.forEach(callback => {
+            try {
+              callback(idleTimeMs);
+            } catch (error) {
+              logger.warn("Error in idle callback", { error: error.message });
+            }
+          });
+        } else {
+          clearInterval(this.interval);
+        }
+      }, 1000);
+      
+      this.stopped = false;
+      logger.debug("Idle tracker started");
+    } else {
+      logger.debug("idle.js idle already started");
+    }
+    
+    logExit();
+  }
+
+  stop() {
+    const logExit = logFunctionCall('IdleTracker.stop');
+    
+    logger.debug("idle.js stopping idle tracker");
+    
+    clearInterval(this.interval);
+    this.stopped = true;
+    this.callbacks = [];
+    
+    logExit();
+  }
+
+  onIdleTime(callback) {
+    this.callbacks.push(callback);
+  }
+
+  removeCallback(callback) {
+    const index = this.callbacks.indexOf(callback);
+    if (index > -1) {
+      this.callbacks.splice(index, 1);
+    }
+  }
+}
+
+// Create singleton instance
+const idleTracker = new IdleTracker();
+
+module.exports = () => {
+  return {
+    start: () => idleTracker.start(),
+    stop: () => idleTracker.stop(),
+    onIdleTime: (callback) => idleTracker.onIdleTime(callback)
+  };
+};

package/lib/tracking.js

@@ -0,0 +1,23 @@
+import { logger } from './logger.js';
+import { logTracker } from './logTracker.js';
+
+export async function createPattern(config) {
+  try {
+    logger.info('Adding tracking pattern', config);
+    
+    if (config.patterns) {
+      for (const pattern of config.patterns) {
+        logTracker.startTracking(pattern);
+      }
+    } else if (typeof config === 'string') {
+      logTracker.startTracking(config);
+    } else {
+      throw new Error('Invalid tracking pattern configuration');
+    }
+    
+    return Promise.resolve();
+  } catch (error) {
+    logger.error('Failed to create tracking pattern:', error);
+    throw error;
+  }
+}