@velor/remote-mouse 6.4.8

package/server/remotes/admin/registrar.js

@@ -0,0 +1,94 @@
+import {createLogger} from '../../application/logger.js';
+import {createSocketActionResponder} from '../../connection/socket/socket-action-responder.js';
+import {createAdminEventGuardMiddleware} from './createAdminEventGuardMiddleware.js';
+import {
+  REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_CLIENT,
+  REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_SERVER,
+  REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_CLIENT,
+  REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_SERVER,
+  REMOTE_EVENT_ADMIN_RESULT,
+  REMOTE_EVENT_ADMIN_ROTATE_ENTRY_TOKEN,
+  REMOTE_EVENT_ADMIN_SERVICE_RESTART,
+  REMOTE_EVENT_ADMIN_TOGGLE_QR_OVERLAY,
+  REMOTE_EVENT_ADMIN_UPDATE_CHECK,
+  REMOTE_EVENT_ADMIN_UPDATE_INSTALL,
+} from '../../../utils/remoteCommands.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('events:admin');
+  return log;
+}
+
+export function createAdminEventRegistrar({ adminActions, getSystemConfig }) {
+  const log = getModuleLog();
+  return function registerAdminEvents(socket) {
+    const config = getSystemConfig();
+    const respondAdminAction = createSocketActionResponder({
+      socket,
+      eventName: REMOTE_EVENT_ADMIN_RESULT,
+    });
+    const client = socket.id.slice(0, 8);
+
+    socket.use(createAdminEventGuardMiddleware({
+      isAdminActionsEnabled: config.adminActionsEnabled,
+      client,
+      log,
+      respondAdminAction,
+    }));
+
+    socket.on(REMOTE_EVENT_ADMIN_UPDATE_CHECK, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_UPDATE_CHECK}`);
+      const result = await adminActions.forceUpdateCheck({ clientId: socket.id });
+      respondAdminAction('update-check', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_UPDATE_INSTALL, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_UPDATE_INSTALL}`);
+      const result = await adminActions.installUpdate({ clientId: socket.id });
+      respondAdminAction('update-install', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_SERVICE_RESTART, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_SERVICE_RESTART}`);
+      const result = await adminActions.restartService({ clientId: socket.id });
+      respondAdminAction('service-restart', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_SERVER, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_SERVER}`);
+      const result = await adminActions.openQrBrowserServer({ clientId: socket.id });
+      respondAdminAction('open-qr-browser-server', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_CLIENT, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_CLIENT}`);
+      const result = await adminActions.openQrBrowserClient({ clientId: socket.id });
+      respondAdminAction('open-qr-browser-client', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_SERVER, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_SERVER}`);
+      const result = await adminActions.openServerInfoBrowserServer({ clientId: socket.id });
+      respondAdminAction('open-server-info-browser-server', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_CLIENT, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_CLIENT}`);
+      const result = await adminActions.openServerInfoBrowserClient({ clientId: socket.id });
+      respondAdminAction('open-server-info-browser-client', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_ROTATE_ENTRY_TOKEN, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_ROTATE_ENTRY_TOKEN}`);
+      const result = await adminActions.rotateEntryToken({ clientId: socket.id });
+      respondAdminAction('rotate-entry-token', result);
+    });
+
+    socket.on(REMOTE_EVENT_ADMIN_TOGGLE_QR_OVERLAY, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_ADMIN_TOGGLE_QR_OVERLAY}`);
+      const result = await adminActions.toggleQrOverlay({ clientId: socket.id });
+      respondAdminAction('toggle-qr-overlay', result);
+    });
+  };
+}

package/server/remotes/browser/actions/createFocusOrLaunchBrowserAction.js

@@ -0,0 +1,22 @@
+import { getBrowserCatalogEntry } from '../browserCatalog.js';
+import { createBrowserAppSpec } from '../spec.js';
+
+export function createFocusOrLaunchBrowserAction(state, osService) {
+  return async function focusOrLaunchBrowser(browserId) {
+    if (state.inFlight) {
+      return false;
+    }
+    state.inFlight = true;
+
+    try {
+      const browser = getBrowserCatalogEntry(browserId);
+      if (!browser) {
+        return false;
+      }
+
+      return osService.app.openOrFocus(createBrowserAppSpec(browser), { maximize: true });
+    } finally {
+      state.inFlight = false;
+    }
+  };
+}

package/server/remotes/browser/actions/openUrlOnHost.js

@@ -0,0 +1,3 @@
+export async function openUrlOnHost(osService, url) {
+  return osService.url.open(url);
+}

package/server/remotes/browser/browserCatalog.js

@@ -0,0 +1,70 @@
+export const BROWSER_CATALOG = [
+  {
+    id: 'brave',
+    name: 'Brave',
+    shortLabel: 'Brave',
+    linuxCommands: ['brave-browser', 'brave'],
+    linuxProcessNames: ['brave-browser', 'brave'],
+    linuxWindowClasses: ['brave'],
+    linuxWindowNames: ['Brave'],
+    linuxFlatpakAppId: 'com.brave.Browser',
+    darwinApps: ['Brave Browser'],
+    winCommands: ['brave'],
+  },
+  {
+    id: 'chrome',
+    name: 'Google Chrome',
+    shortLabel: 'Chrome',
+    linuxCommands: ['google-chrome', 'google-chrome-stable'],
+    linuxProcessNames: ['google-chrome', 'chrome'],
+    linuxWindowClasses: ['google-chrome', 'chrome'],
+    linuxWindowNames: ['Google Chrome', 'Chrome'],
+    darwinApps: ['Google Chrome'],
+    winCommands: ['chrome'],
+  },
+  {
+    id: 'chromium',
+    name: 'Chromium',
+    shortLabel: 'Chromium',
+    linuxCommands: ['chromium-browser', 'chromium'],
+    linuxProcessNames: ['chromium-browser', 'chromium'],
+    linuxWindowClasses: ['chromium-browser', 'chromium'],
+    linuxWindowNames: ['Chromium'],
+    darwinApps: ['Chromium'],
+    winCommands: ['chromium'],
+  },
+  {
+    id: 'edge',
+    name: 'Microsoft Edge',
+    shortLabel: 'Edge',
+    linuxCommands: ['microsoft-edge', 'microsoft-edge-stable'],
+    linuxProcessNames: ['microsoft-edge', 'msedge'],
+    linuxWindowClasses: ['microsoft-edge', 'msedge'],
+    linuxWindowNames: ['Microsoft Edge', 'Edge'],
+    darwinApps: ['Microsoft Edge'],
+    winCommands: ['msedge', 'microsoft-edge'],
+  },
+  {
+    id: 'firefox',
+    name: 'Firefox',
+    shortLabel: 'Firefox',
+    linuxCommands: ['firefox'],
+    linuxProcessNames: ['firefox'],
+    linuxWindowClasses: ['firefox'],
+    linuxWindowNames: ['Firefox'],
+    darwinApps: ['Firefox'],
+    winCommands: ['firefox'],
+  },
+  {
+    id: 'safari',
+    name: 'Safari',
+    shortLabel: 'Safari',
+    linuxCommands: [],
+    darwinApps: ['Safari'],
+    winCommands: [],
+  },
+];
+
+export function getBrowserCatalogEntry(browserId) {
+  return BROWSER_CATALOG.find((browser) => browser.id === browserId) || null;
+}

package/server/remotes/browser/index.js

@@ -0,0 +1,15 @@
+import { createBrowserReceiverState } from './state.js';
+import { createFocusOrLaunchBrowserAction } from './actions/createFocusOrLaunchBrowserAction.js';
+import {openUrlOnHost} from './actions/openUrlOnHost.js';
+import { listBrowsersOnHost } from './listBrowsersOnHost.js';
+
+export function createBrowser(osService) {
+  const state = createBrowserReceiverState();
+  const focusOrLaunchBrowser = createFocusOrLaunchBrowserAction(state, osService);
+
+  return {
+    focusOrLaunchBrowser,
+    listBrowsers: () => listBrowsersOnHost(osService),
+    openUrlOnHost: (url) => openUrlOnHost(osService, url),
+  };
+}

package/server/remotes/browser/listBrowsersOnHost.js

@@ -0,0 +1,23 @@
+import { BROWSER_CATALOG } from './browserCatalog.js';
+import { createBrowserAppSpec } from './spec.js';
+
+export async function listBrowsersOnHost(osService) {
+  const browsers = [];
+
+  for (const browser of BROWSER_CATALOG) {
+    const resolved = await osService.app.resolve(createBrowserAppSpec(browser));
+    if (!resolved) {
+      continue;
+    }
+
+    browsers.push({
+      id: browser.id,
+      name: browser.name,
+      shortLabel: browser.shortLabel,
+      command: resolved.launchCommand || resolved.command || '',
+      app: resolved.appName || '',
+    });
+  }
+
+  return browsers;
+}

package/server/remotes/browser/registrar.js

@@ -0,0 +1,29 @@
+import {createLogger} from "../../application/logger.js";
+import { REMOTE_EVENT_BROWSER_OPEN } from '../../../utils/remoteCommands.js';
+
+let log;
+function getModuleLog() {
+    log ??= createLogger('browser:remote');
+    return log;
+}
+
+function isBrowserEnabled(config, browserId) {
+    return config?.browser?.enabled !== false && config?.browser?.[browserId] !== false;
+}
+
+export const createBrowserRegistrar = ({browser, getConfig = () => ({})}) => {
+    const log = getModuleLog();
+    return socket => {
+        const client = socket.id.slice(0, 8);
+
+        socket.on(REMOTE_EVENT_BROWSER_OPEN, async (payload = {}) => {
+            const browserId = typeof payload?.browserId === 'string' ? payload.browserId : 'brave';
+            if (!isBrowserEnabled(getConfig(), browserId)) {
+                log.info({client, browserId}, 'Browser ignore: desactive par configuration.');
+                return;
+            }
+            log.info({client, browserId}, `Demande ${REMOTE_EVENT_BROWSER_OPEN}`);
+            await browser.focusOrLaunchBrowser(browserId);
+        });
+    }
+};

package/server/remotes/browser/spec.js

@@ -0,0 +1,18 @@
+export function createBrowserAppSpec(browser) {
+  return {
+    linux: {
+      commands: browser.linuxCommands ?? [],
+      flatpakAppId: browser.linuxFlatpakAppId,
+      processNames: browser.linuxProcessNames ?? browser.linuxCommands ?? [],
+      windowClasses: browser.linuxWindowClasses ?? [],
+      windowNames: browser.linuxWindowNames ?? [],
+    },
+    darwin: {
+      apps: browser.darwinApps ?? [],
+    },
+    win32: {
+      commands: browser.winCommands ?? [],
+      windowTitles: [browser.name, browser.shortLabel].filter(Boolean),
+    },
+  };
+}

package/server/remotes/browser/state.js

@@ -0,0 +1,5 @@
+export function createBrowserReceiverState() {
+  return {
+    inFlight: false,
+  };
+}

package/server/remotes/input/registrar.js

@@ -0,0 +1,39 @@
+import {
+  REMOTE_EVENT_KEYBOARD_KEY,
+  REMOTE_EVENT_KEYBOARD_TEXT,
+  REMOTE_EVENT_MOUSE_BUTTON,
+  REMOTE_EVENT_MOUSE_CLICK,
+  REMOTE_EVENT_MOUSE_MOVE,
+  REMOTE_EVENT_MOUSE_SCROLL,
+} from '../../../utils/remoteCommands.js';
+
+export function createControlEventRegistrar({ mouse, keyboard }) {
+    return function registerControlEvents(socket) {
+    socket.on(REMOTE_EVENT_MOUSE_MOVE, async (payload = {}) => {
+      const dx = Number(payload.dx) || 0;
+      const dy = Number(payload.dy) || 0;
+      await mouse.move(dx, dy);
+    });
+
+    socket.on(REMOTE_EVENT_MOUSE_CLICK, (payload = {}) => {
+      mouse.click(payload.button);
+    });
+
+    socket.on(REMOTE_EVENT_MOUSE_BUTTON, (payload = {}) => {
+      mouse.setButtonState(payload.button, payload.state);
+    });
+
+    socket.on(REMOTE_EVENT_MOUSE_SCROLL, (payload = {}) => {
+      const dy = Number(payload.dy) || 0;
+      mouse.scroll(dy);
+    });
+
+    socket.on(REMOTE_EVENT_KEYBOARD_TEXT, (payload = {}) => {
+      keyboard.typeText(payload.text);
+    });
+
+    socket.on(REMOTE_EVENT_KEYBOARD_KEY, (payload = {}) => {
+      keyboard.pressSpecialKey(payload.key, payload.modifiers);
+    });
+  };
+}

package/server/remotes/preview/bgraToRgbaBuffer.js

@@ -0,0 +1,20 @@
+export function bgraToRgbaBuffer(capture, width, height) {
+    const rgba = Buffer.allocUnsafe(width * height * 4);
+    const source = capture.image;
+    const byteWidth = capture.byteWidth;
+
+    let out = 0;
+    for (let row = 0; row < height; row += 1) {
+        const rowStart = row * byteWidth;
+        for (let col = 0; col < width; col += 1) {
+            const i = rowStart + col * 4;
+            rgba[out] = source[i + 2];
+            rgba[out + 1] = source[i + 1];
+            rgba[out + 2] = source[i];
+            rgba[out + 3] = 255;
+            out += 4;
+        }
+    }
+
+    return rgba;
+}

package/server/remotes/preview/captureAroundCursor.js

@@ -0,0 +1,19 @@
+import {clamp} from "../../../utils/math.js";
+
+export function captureAroundCursor(robot, width, height, screen) {
+    const cursor = robot.getMousePos();
+
+    const x = clamp(Math.round(cursor.x - width / 2), 0, Math.max(0, screen.width - width));
+    const y = clamp(Math.round(cursor.y - height / 2), 0, Math.max(0, screen.height - height));
+
+    const capture = robot.screen.capture(x, y, width, height);
+    return {
+        capture,
+        x,
+        y,
+        cursorX: Math.round(cursor.x),
+        cursorY: Math.round(cursor.y),
+        cursorFrameX: Math.round(cursor.x - x),
+        cursorFrameY: Math.round(cursor.y - y),
+    };
+}

package/server/remotes/preview/createPreviewStreamer.js

@@ -0,0 +1,85 @@
+import {captureAroundCursor} from "./captureAroundCursor.js";
+import {bgraToRgbaBuffer} from "./bgraToRgbaBuffer.js";
+import {DEFAULT_PERSISTED_CONFIG} from '../../services/config/defaultConfig.js';
+
+export function createPreviewStreamer(services) {
+  function getPreviewConfig() {
+    return {
+      ...DEFAULT_PERSISTED_CONFIG.preview,
+      ...services.getConfig().preview,
+    };
+  }
+
+  function startForSocket(socket) {
+    let active = true;
+    let timer = null;
+
+    function scheduleNextFrame() {
+      const previewConfig = getPreviewConfig();
+      const fps = Number(previewConfig.fps) || DEFAULT_PERSISTED_CONFIG.preview.fps;
+      const intervalMs = Math.max(50, Math.round(1000 / fps));
+
+      timer = setTimeout(async () => {
+        if (!active) {
+          return;
+        }
+
+        try {
+          const robot = services.getRobot();
+          const currentPreviewConfig = getPreviewConfig();
+          const frameWidth = Number(currentPreviewConfig.width) || DEFAULT_PERSISTED_CONFIG.preview.width;
+          const frameHeight = Number(currentPreviewConfig.height) || DEFAULT_PERSISTED_CONFIG.preview.height;
+          const screen = await services.getSystem().getScreenInfo();
+          if (!screen) {
+            throw new Error('Screen size unavailable');
+          }
+          const {
+            capture,
+            x,
+            y,
+            cursorX,
+            cursorY,
+            cursorFrameX,
+            cursorFrameY,
+          } = captureAroundCursor(robot, frameWidth, frameHeight, screen);
+          const frame = bgraToRgbaBuffer(capture, frameWidth, frameHeight);
+          socket.emit(
+            'preview:frame',
+            {
+              width: frameWidth,
+              height: frameHeight,
+              x,
+              y,
+              cursorX,
+              cursorY,
+              cursorFrameX,
+              cursorFrameY,
+            },
+            frame,
+          );
+        } catch (_error) {
+          // Best effort: ignore frame errors to avoid breaking remote control.
+        }
+
+        scheduleNextFrame();
+      }, intervalMs);
+    }
+
+    scheduleNextFrame();
+
+    const stop = () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+
+    return { stop };
+  }
+
+  return { startForSocket };
+}

package/server/remotes/preview/registrar.js

@@ -0,0 +1,34 @@
+import {
+  REMOTE_EVENT_PREVIEW_START,
+  REMOTE_EVENT_PREVIEW_STOP,
+} from '../../../utils/remoteCommands.js';
+
+export function createPreviewEventRegistrar({ preview, getConfig = () => ({}) }) {
+  return function registerPreviewEvents(socket) {
+    let previewSession = null;
+
+    function startPreview() {
+      if (getConfig()?.preview?.enabled === false) {
+        stopPreview();
+        return;
+      }
+
+      if (previewSession) {
+        return;
+      }
+      previewSession = preview.startForSocket(socket);
+    }
+
+    function stopPreview() {
+      if (!previewSession) {
+        return;
+      }
+      previewSession.stop();
+      previewSession = null;
+    }
+
+    socket.on(REMOTE_EVENT_PREVIEW_START, startPreview);
+    socket.on(REMOTE_EVENT_PREVIEW_STOP, stopPreview);
+    socket.on('disconnect', stopPreview);
+  };
+}