dashcam 0.8.3 → 1.0.1-beta.2

package/examples/execute-script.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * Example: Execute JavaScript on a webpage through the Chrome extension
+ * 
+ * This demonstrates how to:
+ * 1. Connect to the Chrome extension via WebSocket
+ * 2. Send JavaScript code to execute on the active tab
+ * 3. Receive the execution results back
+ */
+
+import { server } from '../lib/websocket/server.js';
+import { WebTrackerManager } from '../lib/extension-logs/manager.js';
+import { logger } from '../lib/logger.js';
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log('║  Chrome Extension Script Execution Example                    ║');
+  console.log('╚════════════════════════════════════════════════════════════════╝\n');
+  console.log('📋 Prerequisites:');
+  console.log('  1. Chrome extension must be installed and loaded');
+  console.log('  2. Have a regular webpage open (NOT chrome:// or chrome-extension://)');
+  console.log('  3. For best results, navigate to a simple page like example.com\n');
+  
+  console.log('Starting WebSocket server...');
+  
+  // Start the WebSocket server
+  await server.start();
+  console.log('✓ WebSocket server started on port:', server.port);
+  
+  // Create the WebTrackerManager
+  const manager = new WebTrackerManager(server);
+  
+  // Wait for the Chrome extension to connect
+  console.log('\nWaiting for Chrome extension to connect...');
+  const connected = await new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      console.log('⏱️  Timeout waiting for connection');
+      resolve(false);
+    }, 10000);
+    
+    const cleanup = server.on('connection', (client) => {
+      console.log('✓ Chrome extension connected!');
+      clearTimeout(timeout);
+      cleanup();
+      resolve(true);
+    });
+  });
+  
+  if (!connected) {
+    console.error('\n❌ Chrome extension did not connect.');
+    console.error('   Make sure the extension is installed and running.');
+    console.error('   Check chrome://extensions to verify it\'s loaded.');
+    process.exit(1);
+  }
+  
+  // Give it a moment to fully initialize
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  console.log('\n--- Example 1: Get page title ---');
+  try {
+    const result = await manager.executeScript({
+      code: 'return document.title;'
+    });
+    console.log('✓ Page title:', result);
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+  }
+  
+  console.log('\n--- Example 2: Get current URL ---');
+  try {
+    const result = await manager.executeScript({
+      code: 'return window.location.href;'
+    });
+    console.log('Current URL:', result);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+  
+  console.log('\n--- Example 3: Change page background color ---');
+  try {
+    const result = await manager.executeScript({
+      code: `
+        document.body.style.backgroundColor = '#ffcccc';
+        return 'Background color changed!';
+      `
+    });
+    console.log('Result:', result);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+  
+  console.log('\n--- Example 4: Insert a message on the page ---');
+  try {
+    const result = await manager.executeScript({
+      code: `
+        const div = document.createElement('div');
+        div.style.cssText = 'position: fixed; top: 20px; right: 20px; background: #4CAF50; color: white; padding: 20px; border-radius: 8px; font-family: Arial; z-index: 10000; box-shadow: 0 4px 6px rgba(0,0,0,0.1);';
+        div.textContent = 'Hello from CLI! 👋';
+        document.body.appendChild(div);
+        
+        // Remove after 5 seconds
+        setTimeout(() => div.remove(), 5000);
+        
+        return 'Message inserted successfully!';
+      `
+    });
+    console.log('Result:', result);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+  
+  console.log('\n--- Example 5: Get all links on the page ---');
+  try {
+    const result = await manager.executeScript({
+      code: `
+        const links = Array.from(document.querySelectorAll('a'))
+          .map(a => ({ text: a.textContent.trim().substring(0, 50), href: a.href }))
+          .slice(0, 5);
+        return links;
+      `
+    });
+    console.log('First 5 links:', JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+  
+  console.log('\n--- Example 6: Execute with error handling ---');
+  try {
+    const result = await manager.executeScript({
+      code: `
+        // This will cause an error
+        nonExistentVariable.doSomething();
+        return 'This will not be returned';
+      `
+    });
+    console.log('Result:', result);
+  } catch (error) {
+    console.error('Expected error caught:', error.message);
+  }
+  
+  console.log('\n--- All examples completed! ---');
+  
+  // Clean up
+  await server.stop();
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/examples/simple-test.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { server } from '../lib/websocket/server.js';
+import { WebTrackerManager } from '../lib/extension-logs/manager.js';
+
+async function main() {
+  console.log('Simple test - make sure you have example.com or any webpage open\n');
+  
+  await server.start();
+  console.log('Server started on port:', server.port);
+  
+  const manager = new WebTrackerManager(server);
+  
+  console.log('Waiting for extension...');
+  await new Promise((resolve) => {
+    const cleanup = server.on('connection', () => {
+      console.log('Connected!\n');
+      cleanup();
+      resolve();
+    });
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  console.log('Test: Get page DOM');
+  const result = await manager.getPageDOM();
+  console.log('Title:', result.title);
+  console.log('URL:', result.url);
+  console.log('HTML length:', result.html.length, 'characters\n');
+  
+  console.log(result.html)
+
+  await server.stop();
+  process.exit(0);
+}
+
+main().catch(console.error);

package/lib/applicationTracker.js

@@ -0,0 +1,311 @@
+import { logger, logFunctionCall } from './logger.js';
+import { extractIcon, getIconData } from './tracking/icons/index.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+// Lazy-loaded get-windows module (will be loaded on first use)
+let activeWindowSync = null;
+let getWindowsLoadAttempted = false;
+let usingSystemTracker = false;
+
+async function loadGetWindows() {
+  if (getWindowsLoadAttempted) {
+    return activeWindowSync;
+  }
+  
+  getWindowsLoadAttempted = true;
+  
+  try {
+    // Try to import get-windows - will work if node_modules is available
+    // or if running from source
+    const getWindows = await import('get-windows');
+    activeWindowSync = getWindows.activeWindowSync;
+    logger.info('Successfully loaded get-windows for application tracking');
+    return activeWindowSync;
+  } catch (error) {
+    const isPkg = typeof process.pkg !== 'undefined';
+    
+    if (isPkg) {
+      logger.info('Using system-based window tracking (pkg build fallback)');
+      usingSystemTracker = true;
+    } else {
+      logger.warn('get-windows not available, falling back to system commands', {
+        error: error.message
+      });
+      usingSystemTracker = true;
+    }
+    return null;
+  }
+}
+
+/**
+ * Enhanced Application tracker for CLI
+ * Uses desktop app patterns for tracking active applications and extracting icons
+ */
+class ApplicationTracker {
+  constructor() {
+    this.isTracking = false;
+    this.trackingInterval = null;
+    this.trackedApps = new Set();
+    this.appEvents = [];
+    this.failedAttempts = 0;
+    this.maxFailedAttempts = 5;
+    
+    // Create a temporary directory for tracking logs
+    this.trackingDir = path.join(os.tmpdir(), 'dashcam-cli-tracking');
+    this.logFile = path.join(this.trackingDir, 'active-win.jsonl');
+    
+    // Ensure tracking directory exists
+    if (!fs.existsSync(this.trackingDir)) {
+      fs.mkdirSync(this.trackingDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Start tracking active applications
+   */
+  start() {
+    const logExit = logFunctionCall('ApplicationTracker.start');
+    
+    if (this.isTracking) {
+      logger.debug('Application tracking already started');
+      logExit();
+      return;
+    }
+
+    logger.debug('Starting enhanced application tracking', {
+      trackingDir: this.trackingDir,
+      logFile: this.logFile
+    });
+    
+    this.isTracking = true;
+    this.trackedApps.clear();
+    this.appEvents = [];
+    this.failedAttempts = 0;
+
+    // Clear previous tracking log
+    if (fs.existsSync(this.logFile)) {
+      fs.unlinkSync(this.logFile);
+    }
+
+    // Track active window every second (same as desktop app)
+    this.trackingInterval = setInterval(() => {
+      this.trackActiveWindow();
+    }, 10000);
+
+    logExit();
+  }
+
+  /**
+   * Stop tracking active applications
+   */
+  stop() {
+    const logExit = logFunctionCall('ApplicationTracker.stop');
+    
+    if (!this.isTracking) {
+      logger.debug('Application tracking not started');
+      logExit();
+      return this.getResults();
+    }
+
+    logger.debug('Stopping enhanced application tracking');
+    this.isTracking = false;
+    
+    if (this.trackingInterval) {
+      clearInterval(this.trackingInterval);
+      this.trackingInterval = null;
+    }
+
+    const results = this.getResults();
+    logger.info('Enhanced application tracking stopped', {
+      uniqueApps: results.apps.length,
+      totalEvents: this.appEvents.length,
+      iconsExtracted: results.icons.filter(icon => icon.file).length
+    });
+
+    logExit();
+    return results;
+  }
+
+  /**
+   * Track the currently active window (using desktop app patterns)
+   */
+  async trackActiveWindow() {
+    // Lazy load get-windows on first use
+    const getWindowsFn = await loadGetWindows();
+
+    if (this.failedAttempts >= this.maxFailedAttempts) {
+      logger.warn('Too many failed attempts, stopping application tracking');
+      this.stop();
+      return;
+    }
+
+    try {
+      let activeWindow = null;
+      
+      // Try native module
+      if (getWindowsFn) {
+        activeWindow = getWindowsFn();
+      } else {
+        if (this.failedAttempts === 0) {
+          logger.info('Application tracking unavailable (get-windows module not available)');
+        }
+        this.failedAttempts = this.maxFailedAttempts;
+        this.stop();
+        return;
+      }
+      
+      if (activeWindow) {
+        const appName = this.normalizeAppName(activeWindow.owner?.name);
+        const appId = activeWindow.owner?.bundleId || activeWindow.owner?.path;
+        
+        if (appName) {
+          // Track unique apps
+          this.trackedApps.add(appName);
+          
+          // Create event object (same format as desktop app)
+          const event = {
+            title: activeWindow.title,
+            time: Date.now(),
+            owner: {
+              id: appId,
+              name: appName
+            }
+          };
+          
+          this.appEvents.push(event);
+          
+          // Extract icon for this application (async, non-blocking)
+          if (appId) {
+            extractIcon({ name: appName, id: appId }).catch(error => {
+              logger.debug('Icon extraction failed', { 
+                app: appName, 
+                error: error.message 
+              });
+            });
+          }
+          
+          // Log to JSONL file (same as desktop app)
+          this.appendToLog(event);
+          
+          // Reset failed attempts on success
+          this.failedAttempts = 0;
+          
+          logger.silly('Tracked active window with icon extraction', {
+            app: appName,
+            title: activeWindow.title?.substring(0, 50),
+            hasId: !!appId
+          });
+        }
+      } else {
+        logger.debug('No active window detected');
+        this.failedAttempts++;
+      }
+    } catch (error) {
+      this.failedAttempts++;
+      logger.warn('Failed to get active window', {
+        error: error.message,
+        attempt: this.failedAttempts
+      });
+    }
+  }
+
+  /**
+   * Append event to JSONL log file
+   */
+  appendToLog(event) {
+    try {
+      const line = JSON.stringify(event) + '\n';
+      fs.appendFileSync(this.logFile, line);
+    } catch (error) {
+      logger.warn('Failed to write to tracking log', { 
+        error: error.message,
+        logFile: this.logFile
+      });
+    }
+  }
+
+  /**
+   * Normalize application name (same logic as desktop app)
+   */
+  normalizeAppName(name) {
+    if (!name) return null;
+    
+    // Remove .exe extension and convert to lowercase
+    name = name.split('.exe')[0];
+    name = name.toLowerCase();
+    return name;
+  }
+
+  /**
+   * Get tracked applications and their icons (enhanced with actual icon data)
+   */
+  getResults() {
+    const apps = Array.from(this.trackedApps);
+    
+    // Extract actual icon data for each app
+    const icons = apps.map(appName => {
+      const iconData = getIconData(appName, false);
+      
+      if (iconData) {
+        return {
+          name: appName,
+          extension: iconData.extension,
+          file: iconData.file // Actual file path to extracted icon
+        };
+      } else {
+        // Fallback for apps without extracted icons
+        return {
+          name: appName,
+          extension: 'png',
+          file: null
+        };
+      }
+    });
+
+    return {
+      apps,
+      icons,
+      events: this.appEvents,
+      logFile: this.logFile // Include path to JSONL log
+    };
+  }
+
+  /**
+   * Get current tracking status
+   */
+  getStatus() {
+    return {
+      isTracking: this.isTracking,
+      uniqueApps: this.trackedApps.size,
+      totalEvents: this.appEvents.length,
+      trackingDir: this.trackingDir,
+      logFile: this.logFile
+    };
+  }
+
+  /**
+   * Clean up tracking files
+   */
+  cleanup() {
+    const logExit = logFunctionCall('ApplicationTracker.cleanup');
+    
+    try {
+      if (fs.existsSync(this.logFile)) {
+        fs.unlinkSync(this.logFile);
+        logger.debug('Cleaned up tracking log file');
+      }
+    } catch (error) {
+      logger.warn('Failed to cleanup tracking files', { error: error.message });
+    }
+    
+    logExit();
+  }
+}
+
+// Create singleton instance
+const applicationTracker = new ApplicationTracker();
+
+export { applicationTracker };
+export default applicationTracker;