dashcam 0.8.4 → 1.0.1-beta.2

package/lib/webLogsDaemon.js

@@ -0,0 +1,234 @@
+import { server } from './websocket/server.js';
+import { WebTrackerManager } from './extension-logs/manager.js';
+import { WebLogsTracker } from './extension-logs/index.js';
+import { logger, setVerbose } from './logger.js';
+import fs from 'fs';
+import path from 'path';
+
+const DAEMON_DIR = path.join(process.cwd(), '.dashcam');
+const DAEMON_PID_FILE = path.join(DAEMON_DIR, 'daemon.pid');
+const DAEMON_CONFIG_FILE = path.join(DAEMON_DIR, 'web-config.json');
+
+// Ensure daemon directory exists
+if (!fs.existsSync(DAEMON_DIR)) {
+  fs.mkdirSync(DAEMON_DIR, { recursive: true });
+}
+
+class WebLogsDaemon {
+  constructor() {
+    this.webTrackerManager = null;
+    this.webWatchTracker = null;
+    this.isRunning = false;
+  }
+
+  async start() {
+    if (this.isRunning) {
+      logger.debug('Web logs daemon already running, skipping start');
+      return;
+    }
+
+    // Enable verbose logging for daemon
+    setVerbose(true);
+    logger.info('Starting web logs daemon...');
+    try {
+      // Start WebSocket server
+      logger.debug('Initializing WebSocket server...');
+      await server.start();
+      logger.info(`WebSocket server started on port ${server.port}`);
+
+      // Create web tracker manager
+      logger.debug('Creating WebTrackerManager...');
+      this.webTrackerManager = new WebTrackerManager(server);
+      
+      // Load existing config if available
+      logger.debug('Loading daemon configuration...');
+      const config = this.loadConfig();
+      logger.debug('Loaded config:', { configKeys: Object.keys(config), configCount: Object.keys(config).length });
+      
+      this.webWatchTracker = new WebLogsTracker({
+        config,
+        webTrackerManager: this.webTrackerManager
+      });
+
+      this.isRunning = true;
+      
+      // Write PID file
+      logger.debug('Writing daemon PID file...');
+      fs.writeFileSync(DAEMON_PID_FILE, process.pid.toString());
+      
+      logger.info('Web logs daemon started successfully');
+
+      // Keep process alive
+      process.on('SIGTERM', () => {
+        logger.info('Received SIGTERM, stopping daemon...');
+        this.stop();
+      });
+      process.on('SIGINT', () => {
+        logger.info('Received SIGINT, stopping daemon...');
+        this.stop();
+      });
+
+    } catch (error) {
+      logger.error('Failed to start web logs daemon', { error: error.message, stack: error.stack });
+      throw error;
+    }
+  }
+
+  stop() {
+    if (!this.isRunning) {
+      logger.debug('Web logs daemon not running, skipping stop');
+      return;
+    }
+
+    logger.info('Stopping web logs daemon...');
+    
+    if (this.webWatchTracker) {
+      logger.debug('Destroying web watch tracker...');
+      this.webWatchTracker.destroy();
+    }
+    
+    if (this.webTrackerManager) {
+      logger.debug('Destroying web tracker manager...');
+      this.webTrackerManager.destroy();
+    }
+    
+    logger.debug('Stopping WebSocket server...');
+    server.stop();
+    
+    // Remove PID file
+    if (fs.existsSync(DAEMON_PID_FILE)) {
+      logger.debug('Removing daemon PID file...');
+      fs.unlinkSync(DAEMON_PID_FILE);
+    }
+    
+    this.isRunning = false;
+    logger.info('Web logs daemon stopped');
+    process.exit(0);
+  }
+
+  updateConfig(config) {
+    logger.debug('Updating daemon config...', { configKeys: Object.keys(config) });
+    if (this.webWatchTracker) {
+      this.webWatchTracker.updateConfig(config);
+    }
+    this.saveConfig(config);
+    logger.info('Daemon config updated successfully');
+  }
+
+  loadConfig() {
+    try {
+      if (fs.existsSync(DAEMON_CONFIG_FILE)) {
+        logger.debug('Loading daemon config from file...', { configFile: DAEMON_CONFIG_FILE });
+        const data = fs.readFileSync(DAEMON_CONFIG_FILE, 'utf8');
+        const config = JSON.parse(data);
+        logger.debug('Daemon config loaded successfully', { configKeys: Object.keys(config) });
+        return config;
+      } else {
+        logger.debug('No daemon config file found, using empty config');
+      }
+    } catch (error) {
+      logger.error('Failed to load daemon config', { error: error.message, configFile: DAEMON_CONFIG_FILE });
+    }
+    return {};
+  }
+
+  saveConfig(config) {
+    try {
+      logger.debug('Saving daemon config to file...', { configFile: DAEMON_CONFIG_FILE, configKeys: Object.keys(config) });
+      fs.writeFileSync(DAEMON_CONFIG_FILE, JSON.stringify(config, null, 2));
+      logger.debug('Daemon config saved successfully');
+    } catch (error) {
+      logger.error('Failed to save daemon config', { error: error.message, configFile: DAEMON_CONFIG_FILE });
+    }
+  }
+
+  static isDaemonRunning() {
+    try {
+      if (!fs.existsSync(DAEMON_PID_FILE)) {
+        logger.debug('Daemon PID file does not exist, daemon not running');
+        return false;
+      }
+      
+      const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim());
+      if (isNaN(pid)) {
+        logger.warn('Invalid PID in daemon PID file', { pidFile: DAEMON_PID_FILE });
+        return false;
+      }
+      
+      logger.debug('Checking if daemon process is still running...', { pid });
+      // Check if process is still running
+      process.kill(pid, 0);
+      logger.debug('Daemon process is running', { pid });
+      return true;
+    } catch (error) {
+      logger.debug('Daemon process not running or not accessible', { error: error.message });
+      return false;
+    }
+  }
+
+  static async ensureDaemonRunning() {
+    if (!WebLogsDaemon.isDaemonRunning()) {
+      logger.info('Web logs daemon not running, starting it...');
+      
+      // Spawn daemon process
+      const { spawn } = await import('child_process');
+      const child = spawn('node', [
+        path.join(process.cwd(), 'bin/dashcam.js'),
+        '_internal_daemon'
+      ], {
+        detached: true,
+        stdio: 'inherit'  // Changed from 'ignore' to 'inherit' for debugging
+      });
+      
+      logger.debug('Spawned daemon process', { pid: child.pid });
+      child.unref();
+      
+      // Wait a moment for daemon to start
+      logger.debug('Waiting for daemon to start...');
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      if (!WebLogsDaemon.isDaemonRunning()) {
+        logger.error('Failed to start web logs daemon after spawn attempt');
+        throw new Error('Failed to start web logs daemon');
+      } else {
+        logger.info('Web logs daemon started successfully');
+      }
+    } else {
+      logger.debug('Web logs daemon already running');
+    }
+  }
+
+  static stopDaemon() {
+    try {
+      if (!fs.existsSync(DAEMON_PID_FILE)) {
+        logger.debug('No daemon PID file found, daemon not running');
+        return false;
+      }
+      
+      const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim());
+      if (isNaN(pid)) {
+        logger.warn('Invalid PID in daemon PID file');
+        return false;
+      }
+      
+      logger.info('Stopping daemon process...', { pid });
+      process.kill(pid, 'SIGTERM');
+      
+      // Wait for cleanup
+      setTimeout(() => {
+        if (fs.existsSync(DAEMON_PID_FILE)) {
+          logger.debug('Removing daemon PID file after cleanup timeout');
+          fs.unlinkSync(DAEMON_PID_FILE);
+        }
+      }, 1000);
+      
+      logger.info('Daemon stop signal sent');
+      return true;
+    } catch (error) {
+      logger.error('Failed to stop daemon', { error: error.message });
+      return false;
+    }
+  }
+}
+
+export { WebLogsDaemon, DAEMON_CONFIG_FILE };

package/lib/websocket/server.js

@@ -0,0 +1,223 @@
+import { WebSocketServer } from 'ws';
+import { logger } from '../logger.js';
+
+// Simple ref implementation for reactivity (adapted from Vue's ref)
+function ref(value) {
+  return {
+    value,
+    _isRef: true
+  };
+}
+
+class WSServer {
+  #socket = null;
+  #handlers = {};
+  
+  constructor(ports) {
+    this.ports = ports;
+    this.port = null;
+    this.isListening = ref(false);
+  }
+
+  on(event, handler) {
+    if (!this.#handlers[event]) this.#handlers[event] = [];
+    if (this.#handlers[event].find((cb) => cb === handler))
+      throw new Error('Handler already registered');
+    this.#handlers[event].push(handler);
+    return () => {
+      this.#handlers[event] = this.#handlers[event].filter((cb) => cb !== handler);
+    };
+  }
+
+  emit(event, payload) {
+    if (!this.#handlers[event]) return;
+    for (const cb of this.#handlers[event]) {
+      try {
+        cb(payload);
+      } catch (err) {
+        logger.error(
+          'Failed calling handler for event ' +
+            event +
+            ' with error ' +
+            err.message
+        );
+      }
+    }
+  }
+
+  async start() {
+    if (this.#socket) {
+      logger.error('The websocket server is already started');
+      return;
+    }
+    
+    logger.debug('WebSocketServer: Starting server, trying ports...', { ports: this.ports });
+    for (const port of this.ports) {
+      const ws = await new Promise((resolve) => {
+        logger.debug('WebSocketServer: Trying port ' + port);
+        const ws = new WebSocketServer({ port, host: '127.0.0.1' });
+        ws.on('error', () => {
+          logger.debug('WebSocketServer: Failed to listen on port ' + port);
+          resolve();
+        });
+        ws.on('listening', () => {
+          logger.debug('WebSocketServer: Successfully listening on port ' + port);
+          resolve(ws);
+        });
+      });
+
+      if (ws) return this.#setup(ws, port);
+    }
+    throw new Error('Unable to listen to any of the provided ports');
+  }
+
+    #setup(socket, port) {
+    logger.debug('WebSocketServer: Setting up server on port', { port });
+    
+    const states = {
+      NEW: 'NEW',
+      SENT_HEADERS: 'SENT_HEADERS',
+      CONNECTED: 'CONNECTED',
+    };
+
+    this.port = port;
+    this.#socket = socket;
+
+    this.#socket.on('close', (arg) => {
+      logger.debug('WebSocketServer: Server closed', { arg });
+      this.#socket = null;
+      this.isListening.value = false;
+      this.emit('close', arg);
+    });
+    this.#socket.on('error', (arg) => {
+      logger.error('WebSocketServer: Server error', { error: arg });
+      this.#socket = null;
+      this.isListening.value = false;
+      this.emit('error', arg);
+    });
+
+    this.#socket.on('connection', (client) => {
+      logger.info('WebSocketServer: New client connection established');
+      
+      let state = states.NEW;
+      const failValidation = () => {
+        logger.warn('WebSocketServer: Client validation failed, closing connection');
+        client.send(
+          JSON.stringify({ error: 'Unidentified client, closing socket' })
+        );
+        client.close();
+      };
+
+      const timeout = setTimeout(() => {
+        if (state === states.CONNECTED) return;
+        logger.warn('WebSocketServer: Client validation timeout, closing connection');
+        failValidation();
+        clearTimeout(timeout);
+      }, 10000);
+
+      client.on('message', (data, isBinary) => {
+        let message = isBinary ? data : data.toString();
+        logger.debug('WebSocketServer: Received message from client', { 
+          isBinary, 
+          messageLength: message.length,
+          state 
+        });
+        
+        try {
+          message = JSON.parse(message);
+          logger.debug('WebSocketServer: Parsed message', { type: message.type, hasPayload: !!message.payload });
+        } catch (err) {
+          logger.debug('WebSocketServer: Message is not JSON, treating as raw string');
+        }
+        
+        if (state === states.SENT_HEADERS) {
+          if (message === 'dashcam_extension_socket_confirm') {
+            state = states.CONNECTED;
+            logger.info('WebSocketServer: Client successfully validated and connected');
+            this.emit('connection', client);
+            return;
+          }
+          logger.warn('WebSocketServer: Invalid confirmation message from client');
+          failValidation();
+          clearTimeout(timeout);
+        }
+
+        this.emit('message', message, client);
+      });
+
+      logger.debug('WebSocketServer: Sending connection header to client');
+      client.send('dashcam_desktop_socket_connected', (err) => {
+        if (err) {
+          logger.error('WebSocketServer: Failed to send connection header', { error: err.message });
+          client.close();
+          clearTimeout(timeout);
+        } else {
+          logger.debug('WebSocketServer: Connection header sent, waiting for confirmation');
+          state = states.SENT_HEADERS;
+        }
+      });
+    });
+    
+    this.isListening.value = true;
+    logger.info('WebSocketServer: Setup complete, server is listening', { port });
+    this.emit('listening', port);
+  }
+
+  broadcast(message) {
+    if (!this.#socket) {
+      logger.error('WebSocketServer: Cannot broadcast, server not currently running');
+      throw new Error('Server not currently running');
+    }
+    
+    logger.debug('WebSocketServer: Broadcasting message to all clients', { 
+      clientCount: this.#socket.clients.size,
+      messageType: message.type || 'raw'
+    });
+    
+    this.#socket.clients.forEach((client) => {
+      try {
+        this.send(client, message);
+      } catch (err) {
+        logger.error('WebSocketServer: Failed to send message to client', { error: err.message });
+      }
+    });
+  }
+
+  send(client, message) {
+    if (!this.#socket) {
+      logger.error('WebSocketServer: Cannot send, server not currently running');
+      throw new Error('Server not currently running');
+    }
+    
+    logger.debug('WebSocketServer: Sending message to client', { 
+      messageType: message.type || 'raw',
+      messageLength: JSON.stringify(message).length
+    });
+    
+    client.send(
+      typeof message === 'string' ? message : JSON.stringify(message)
+    );
+  }
+
+  async stop() {
+    if (this.#socket) {
+      logger.debug('WebSocketServer: Stopping server...');
+      this.#socket.close();
+      this.#socket = null;
+      this.isListening.value = false;
+      logger.info('WebSocketServer: Server stopped');
+    } else {
+      logger.debug('WebSocketServer: Server already stopped');
+    }
+  }
+}
+
+// This list of ports is randomly generated of ports between 10000 and 65000
+// This exact same list of ports needs to be used on the desktop app's websocket server
+const server = new WSServer([
+  10368, 16240, 21855, 24301, 25928,
+  // 27074, 31899, 34205, 36109, 37479, 38986,
+  // 39618, 41890, 47096, 48736, 49893, 53659, 55927, 56001, 62895,
+]);
+
+export { server, ref };

package/package.json

@@ -1,33 +1,62 @@
 {
   "name": "dashcam",
-  "version": "0.8.4",
-  "description": "Fix bugs, close pulls, and update your team with desktop instant replay.",
-  "main": "index.js",
+  "version": "1.0.1-beta.2",
+  "description": "Minimal CLI version of Dashcam desktop app",
+  "main": "bin/index.js",
+  "bin": {
+    "dashcam": "./bin/dashcam.js"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "husky install"
+    "start": "node bin/dashcam.js",
+    "prebuild": "npm run bundle",
+    "bundle": "esbuild bin/dashcam.js --bundle --platform=node --target=node20 --format=cjs --outfile=dist/bundle.cjs --external:@mapbox/node-pre-gyp --external:file-icon --external:get-windows --banner:js=\"const importMetaUrl = typeof document === 'undefined' ? require('url').pathToFileURL(__filename).href : document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href;\" --define:import.meta.url='importMetaUrl'",
+    "build": "pkg dist/bundle.cjs --out-path dist --compress GZip --public",
+    "build:macos": "pkg dist/bundle.cjs --targets node20-macos-x64 --output dist/dashcam-macos-x64 --compress GZip --public && pkg dist/bundle.cjs --targets node20-macos-arm64 --output dist/dashcam-macos-arm64 --compress GZip --public",
+    "build:linux": "pkg dist/bundle.cjs --targets node20-linux-x64 --output dist/dashcam-linux-x64 --compress GZip --public && pkg dist/bundle.cjs --targets node20-linux-arm64 --output dist/dashcam-linux-arm64 --compress GZip --public",
+    "build:windows": "pkg dist/bundle.cjs --targets node20-win-x64 --output dist/dashcam-windows-x64.exe --compress GZip --public && pkg dist/bundle.cjs --targets node20-win-arm64 --output dist/dashcam-windows-arm64.exe --compress GZip --public",
+    "build:all": "npm run build:macos && npm run build:linux && npm run build:windows"
   },
-  "bin": {
-    "dashcam": "index.js"
+  "pkg": {
+    "scripts": "dist/bundle.cjs",
+    "targets": [
+      "node20-macos-x64",
+      "node20-macos-arm64",
+      "node20-linux-x64",
+      "node20-linux-arm64",
+      "node20-win-x64",
+      "node20-win-arm64"
+    ],
+    "outputPath": "dist",
+    "ignore": [
+      "node_modules/get-windows/**",
+      "node_modules/file-icon/**"
+    ]
   },
-  "author": "",
-  "license": "ISC",
   "dependencies": {
-    "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0",
-    "cli-color": "^2.0.3",
-    "commander": "^9.4.0",
-    "find-process": "^1.4.7",
-    "husky": "^7.0.4",
-    "node-ipc": "^10.1.0",
-    "yargs": "^17.3.1"
+    "@aws-sdk/client-s3": "^3.919.0",
+    "@aws-sdk/client-sts": "^3.919.0",
+    "@aws-sdk/lib-storage": "^3.919.0",
+    "auth0": "^4.0.0",
+    "commander": "^11.0.0",
+    "execa": "^9.6.0",
+    "ffmpeg-static": "^5.2.0",
+    "ffprobe-static": "^3.1.0",
+    "file-icon": "^6.0.0",
+    "get-windows": "^9.2.3",
+    "got": "^11.8.6",
+    "mask-sensitive-data": "^0.11.5",
+    "node-fetch": "^2.7.0",
+    "open": "^9.1.0",
+    "tail": "^2.2.6",
+    "winston": "^3.11.0",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
-    "husky": "^7.0.0"
+    "@yao-pkg/pkg": "^6.10.1",
+    "esbuild": "^0.19.0"
   },
+  "type": "module",
   "engines": {
-    "node": ">=22.19.0"
-  },
-  "volta": {
-    "node": "22.19.0"
+    "node": ">=20.0.0"
   }
 }