@velor/remote-mouse 6.4.8

package/server/services/createServicesContainer.js

@@ -0,0 +1,94 @@
+import {createLazy} from "../../utils/createLazy.js";
+import {createLogger} from '../application/logger.js';
+
+const log = createLogger('services:container');
+
+function urlFactory(services) {
+    const {
+        getSystemConfig,
+        getServer,
+        getTokenManager
+    } = services;
+
+    const systemConfig = getSystemConfig();
+    const protocol = String(systemConfig?.protocol || 'http');
+    const port = Number(systemConfig?.port || 0);
+    const publicBaseUrl = getServer().basePublicUrl;
+    const localBaseUrl = `${protocol}://127.0.0.1:${port}`;
+    const tokenManager = getTokenManager();
+    const token = tokenManager.getToken() || tokenManager.createToken();
+    const entryPath = `/api/sessions/${token}`;
+
+    return {
+        publicBaseUrl,
+        localBaseUrl,
+        entryUrl: `${publicBaseUrl}${entryPath}`,
+        qrUrl: `${publicBaseUrl}/qr`,
+        adminConfigUrl: `${publicBaseUrl}/ui/admin/config`,
+        serverInfoUrl: `${publicBaseUrl}/ui/admin/server-info`,
+        healthUrl: `${publicBaseUrl}/health`,
+    }
+}
+
+export async function createServicesContainer({
+                                                  createSystemConfig,
+                                                  createPersistence,
+                                                  createOsService,
+                                                  createSystemService,
+                                                  createConfigService,
+                                                  createSseService,
+                                                  createEventStore,
+                                                  createServiceEvents,
+                                                  createTokenManager,
+                                                  createRobot,
+                                                  createNotifier,
+                                                  createPubSub,
+                                                  createTaskRunner,
+                                                  createTaskManager,
+                                                  createQrOverlay,
+                                                  createUpdateManager,
+                                                  createApplicationDaemonService,
+                                                  createServer,
+                                                  createInputController,
+                                                  createRemotes
+                                              }) {
+    let robotInstance;
+    let qrOverlayInstance;
+
+    let container = {
+        // Lazy providers
+        getSystemConfig: createLazy(() => createSystemConfig(container)),
+        getPersistence: createLazy(() => createPersistence(container)),
+        getOs: createLazy(() => createOsService(container)),
+        getSystem: createLazy(() => createSystemService(container)),
+        getConfigService: createLazy(() => createConfigService(container)),
+        getConfig: () => container.getConfigService().getConfigs(),
+        getSseService: createLazy(() => createSseService(container)),
+        getEventStore: createLazy(() => createEventStore(container)),
+        getEvents: createLazy(() => createServiceEvents(container)),
+        getTokenManager: createLazy(() => createTokenManager(container)),
+        getNotifier: createLazy(() => createNotifier(container)),
+        getPubSub: createLazy(() => createPubSub(container)),
+        getTaskRunner: createLazy(() => createTaskRunner(container)),
+        getTaskManager: createLazy(() => createTaskManager(container)),
+        getServer: createLazy(() => createServer(container)),
+        getQrOverlay: () => qrOverlayInstance,
+        getUpdateManager: createLazy(() => createUpdateManager(container)),
+        getApplicationDaemonService: createLazy(() => createApplicationDaemonService(container)),
+        getUrls: () => urlFactory(container),
+        getInputController: createLazy(() => createInputController(container)),
+        getRemotes: createLazy(() => createRemotes(container)),
+        getRobot: () => robotInstance,
+
+    };
+
+    log.debug('Initialisation service robot');
+    robotInstance = await createRobot(container);
+    log.debug('Service robot initialise');
+
+    log.debug('Initialisation service QR overlay');
+    qrOverlayInstance = await createQrOverlay(container);
+    log.debug('Service QR overlay initialise');
+
+    return container;
+}

package/server/services/createServicesRegistry.js

@@ -0,0 +1,48 @@
+import {createPersistence} from './persistence/index.js';
+import {createServicesContainer,} from './createServicesContainer.js';
+import {loadRobot} from '../utils/robot.js';
+import {createServer} from "./server/createServer.js";
+import {createInputController} from "./input/createInputController.js";
+import {getSystemConfig} from "./config/index.js";
+import {createConfigService} from "./config/configService.js";
+import {createTokenManager} from "./token-manager/createTokenManager.js";
+import {createNotifier} from "./notifier/createNotifier.js";
+import {createTaskRunner} from './task-runner/createTaskRunner.js';
+import {createTaskManager} from './task-manager/createTaskManager.js';
+import {createUpdateManager} from "./update-manager/createUpdateManager.js";
+import {createQrOverlay} from "./overlay/createQrOverlay.js";
+import {createRemotes} from "./remotes/createRemotes.js";
+import {createPubSub} from './pubsub/createPubSub.js';
+import {createEventStore} from './pubsub/createEventStore.js';
+import {createServiceEvents} from './pubsub/createServiceEvents.js';
+import {createSseService} from './sse/createSseService.js';
+import {createApplicationDaemonService} from './application/createApplicationDaemonService.js';
+import {createOsService} from './os/index.js';
+import {createSystemService} from './system/createSystemService.js';
+
+
+export function createServicesRegistry() {
+
+    return createServicesContainer({
+        createSystemConfig: getSystemConfig,
+        createPersistence,
+        createOsService,
+        createSystemService,
+        createConfigService,
+        createSseService,
+        createEventStore,
+        createServiceEvents,
+        createTokenManager,
+        createRobot: loadRobot,
+        createNotifier,
+        createPubSub,
+        createTaskRunner,
+        createTaskManager,
+        createQrOverlay,
+        createUpdateManager,
+        createApplicationDaemonService,
+        createServer,
+        createInputController,
+        createRemotes
+    });
+}

package/server/services/input/createInputController.js

@@ -0,0 +1,17 @@
+import {createKeyboardController} from './createKeyboardController.js';
+import {createMouseController} from './createMouseController.js';
+
+export function createInputController(services) {
+    
+    const mouse = createMouseController(services);
+    const keyboard = createKeyboardController(services);
+    
+    return {
+        mouse,
+        keyboard,
+        updateConfig() {
+            mouse.updateConfig();
+            keyboard.updateConfig();
+        }
+    };
+}

package/server/services/input/createKeyboardController.js

@@ -0,0 +1,146 @@
+const ALLOWED_KEYS = new Set([
+    'enter',
+    'backspace',
+    'tab',
+    'space',
+    'escape',
+    'up',
+    'down',
+    'left',
+    'right',
+    'a',
+    'd',
+    'f',
+    'i',
+    'm',
+    'n',
+    'p',
+    's',
+    't',
+    'w',
+    'l',
+    'f5',
+    'f11',
+    'command',
+]);
+const ALLOWED_MODIFIERS = new Set(['control', 'shift', 'alt', 'command']);
+const DEFAULT_KEYBOARD_DELAY_MS = 20;
+
+function isDirectTypeSafe(character) {
+    return /^[a-zA-Z0-9 ]$/.test(character);
+}
+
+function typeUnicodeCharacter(robot, character) {
+    const codePoint = character.codePointAt(0);
+    if (!codePoint) {
+        return;
+    }
+
+    if (process.platform !== 'linux') {
+        robot.typeString(character);
+        return;
+    }
+
+    robot.keyTap('u', ['control', 'shift']);
+    robot.typeString(codePoint.toString(16));
+    robot.keyTap('enter');
+}
+
+export function createKeyboardController(servicesOrRobot) {
+    const getRobot = servicesOrRobot?.getRobot
+        ? () => servicesOrRobot.getRobot()
+        : () => servicesOrRobot;
+    let keyboardConfigured = false;
+
+    function configureKeyboard(robot) {
+        if (keyboardConfigured) {
+            return;
+        }
+
+        if (typeof robot?.setKeyboardDelay === 'function') {
+            robot.setKeyboardDelay(DEFAULT_KEYBOARD_DELAY_MS);
+        }
+        keyboardConfigured = true;
+    }
+
+    function enqueue(task) {
+        const robot = getRobot();
+        configureKeyboard(robot);
+        return task(robot);
+    }
+
+    function typeText(text) {
+        if (!text || typeof text !== 'string') {
+            return;
+        }
+
+        return enqueue((robot) => {
+            let directBuffer = '';
+            for (const character of Array.from(text)) {
+                if (character === '\n') {
+                    if (directBuffer) {
+                        robot.typeString(directBuffer);
+                        directBuffer = '';
+                    }
+                    robot.keyTap('enter');
+                    continue;
+                }
+
+                if (character === '\t') {
+                    if (directBuffer) {
+                        robot.typeString(directBuffer);
+                        directBuffer = '';
+                    }
+                    robot.keyTap('tab');
+                    continue;
+                }
+
+                if (isDirectTypeSafe(character)) {
+                    directBuffer += character;
+                    continue;
+                }
+
+                if (directBuffer) {
+                    robot.typeString(directBuffer);
+                    directBuffer = '';
+                }
+                typeUnicodeCharacter(robot, character);
+            }
+
+            if (directBuffer) {
+                robot.typeString(directBuffer);
+            }
+        });
+    }
+
+    function pressSpecialKey(key, modifiers = []) {
+        if (!ALLOWED_KEYS.has(key)) {
+            return;
+        }
+
+        return enqueue((robot) => {
+            if (!Array.isArray(modifiers) || modifiers.length === 0) {
+                robot.keyTap(key);
+                return;
+            }
+
+            const sanitizedModifiers = modifiers
+                .filter((value) => typeof value === 'string')
+                .filter((value) => ALLOWED_MODIFIERS.has(value));
+
+            if (sanitizedModifiers.length > 0) {
+                robot.keyTap(key, sanitizedModifiers);
+            } else {
+                robot.keyTap(key);
+            }
+        });
+    }
+
+    return {
+        typeText,
+        pressSpecialKey,
+        updateConfig() {
+            // noOp
+        }
+    };
+}

package/server/services/input/createMouseController.js

@@ -0,0 +1,182 @@
+import {clamp} from '../../../utils/math.js';
+import {DEFAULT_PERSISTED_CONFIG} from '../config/defaultConfig.js';
+
+export function createMouseController(services) {
+    const {
+        getConfig
+    } = services;
+
+    let scrollRemainder = 0;
+    let pressedButton = '';
+    let lastScreenSize = null;
+    let screenSizeOverride = null;
+
+    function getInputConfig() {
+        return getConfig().input || DEFAULT_PERSISTED_CONFIG.input;
+    }
+
+    function getScreenSize(screen) {
+        const width = Number(screen?.width);
+        const height = Number(screen?.height);
+        const normalizedWidth = Number.isFinite(width) && width > 0 ? Math.round(width) : 1;
+        const normalizedHeight = Number.isFinite(height) && height > 0 ? Math.round(height) : 1;
+        return {
+            width: normalizedWidth,
+            height: normalizedHeight,
+            maxX: getMaxCoordinate(normalizedWidth),
+            maxY: getMaxCoordinate(normalizedHeight),
+        };
+    }
+
+    function getMaxCoordinate(size) {
+        const value = Number(size);
+        if (!Number.isFinite(value) || value <= 0) {
+            return 0;
+        }
+        return Math.max(0, Math.round(value) - 1);
+    }
+
+    function getCoordinate(value) {
+        const coordinate = Number(value);
+        return Number.isFinite(coordinate) ? coordinate : 0;
+    }
+
+    function hasScreenSizeChanged(a, b) {
+        return Boolean(a && b && (a.width !== b.width || a.height !== b.height));
+    }
+
+    function scaleCoordinate(coordinate, previousMax, nextMax) {
+        if (previousMax <= 0) {
+            return clamp(Math.round(coordinate), 0, nextMax);
+        }
+        return clamp(Math.round((coordinate / previousMax) * nextMax), 0, nextMax);
+    }
+
+    function getCurrentPosition(current, screenSize) {
+        if (hasScreenSizeChanged(lastScreenSize, screenSize)) {
+            return {
+                x: scaleCoordinate(
+                    clamp(Math.round(getCoordinate(current.x)), 0, lastScreenSize.maxX),
+                    lastScreenSize.maxX,
+                    screenSize.maxX,
+                ),
+                y: scaleCoordinate(
+                    clamp(Math.round(getCoordinate(current.y)), 0, lastScreenSize.maxY),
+                    lastScreenSize.maxY,
+                    screenSize.maxY,
+                ),
+            };
+        }
+
+        return {
+            x: clamp(Math.round(getCoordinate(current.x)), 0, screenSize.maxX),
+            y: clamp(Math.round(getCoordinate(current.y)), 0, screenSize.maxY),
+        };
+    }
+
+    function rememberScreenSize(screenSize) {
+        lastScreenSize = {
+            width: screenSize.width,
+            height: screenSize.height,
+            maxX: screenSize.maxX,
+            maxY: screenSize.maxY,
+        };
+    }
+
+    async function getActiveScreenSize() {
+        if (screenSizeOverride || lastScreenSize) {
+            return getScreenSize(screenSizeOverride || lastScreenSize);
+        }
+
+        return getScreenSize(await services.getSystem().getScreenInfo());
+    }
+
+    function setScreenSizeOverride(screen) {
+        screenSizeOverride = getScreenSize(screen);
+        rememberScreenSize(screenSizeOverride);
+    }
+
+    async function move(dx, dy) {
+        const robot = services.getRobot();
+        const inputConfig = getInputConfig();
+        const mouseSpeed = Number(inputConfig.mouseSpeed) || DEFAULT_PERSISTED_CONFIG.input.mouseSpeed;
+        const screenSize = await getActiveScreenSize();
+        const current = robot.getMousePos();
+        const position = getCurrentPosition(current, screenSize);
+        rememberScreenSize(screenSize);
+        const nextX = clamp(Math.round(position.x + dx * mouseSpeed), 0, screenSize.maxX);
+        const nextY = clamp(Math.round(position.y + dy * mouseSpeed), 0, screenSize.maxY);
+        if (pressedButton === 'left' && typeof robot.dragMouse === 'function') {
+            robot.dragMouse(nextX, nextY);
+            return;
+        }
+        robot.moveMouse(nextX, nextY);
+    }
+
+    function remapToScreenSize(previousScreen, nextScreen) {
+        const robot = services.getRobot();
+        const previousScreenSize = getScreenSize(previousScreen);
+        const nextScreenSize = getScreenSize(nextScreen);
+        const current = robot.getMousePos();
+        const nextX = scaleCoordinate(
+            clamp(Math.round(getCoordinate(current.x)), 0, previousScreenSize.maxX),
+            previousScreenSize.maxX,
+            nextScreenSize.maxX,
+        );
+        const nextY = scaleCoordinate(
+            clamp(Math.round(getCoordinate(current.y)), 0, previousScreenSize.maxY),
+            previousScreenSize.maxY,
+            nextScreenSize.maxY,
+        );
+        screenSizeOverride = nextScreenSize;
+        rememberScreenSize(nextScreenSize);
+        robot.moveMouse(nextX, nextY);
+    }
+
+    function scroll(deltaY) {
+        const robot = services.getRobot();
+        const inputConfig = getInputConfig();
+        const scrollSpeed = Number(inputConfig.scrollSpeed) || DEFAULT_PERSISTED_CONFIG.input.scrollSpeed;
+        const total = -deltaY * scrollSpeed + scrollRemainder;
+        const amount = total > 0 ? Math.floor(total) : Math.ceil(total);
+        scrollRemainder = total - amount;
+        if (amount !== 0) {
+            robot.scrollMouse(0, amount);
+        }
+    }
+
+    function click(button) {
+        const robot = services.getRobot();
+        const mouseButton = button === 'right' ? 'right' : 'left';
+        robot.mouseClick(mouseButton);
+    }
+
+    function setButtonState(button, state) {
+        const robot = services.getRobot();
+        const mouseButton = button === 'right' ? 'right' : 'left';
+        const nextState = state === 'down' ? 'down' : 'up';
+        if (typeof robot.mouseToggle === 'function') {
+            robot.mouseToggle(nextState, mouseButton);
+        } else if (nextState === 'up') {
+            robot.mouseClick(mouseButton);
+        }
+
+        if (nextState === 'down') {
+            pressedButton = mouseButton;
+        } else if (pressedButton === mouseButton) {
+            pressedButton = '';
+        }
+    }
+
+    return {
+        move,
+        scroll,
+        click,
+        setButtonState,
+        remapToScreenSize,
+        setScreenSizeOverride,
+        updateConfig() {
+            return getInputConfig();
+        }
+    };
+}

package/server/services/notifier/createClientNotifier.js

@@ -0,0 +1,23 @@
+import {NOTIFIER_TARGET_ALL_CLIENTS, NOTIFIER_TARGET_CLIENT} from './createNotifierComposite.js';
+import {createLogger} from '../../application/logger.js';
+
+export function createClientNotifier(services) {
+  const log = createLogger('notifier:client');
+  return {
+    notify(payload, options = {}) {
+      const scope = String(options.scope || NOTIFIER_TARGET_ALL_CLIENTS);
+      const clientId = String(options.clientId || '').trim();
+
+      if (scope === NOTIFIER_TARGET_CLIENT) {
+        if (!clientId) {
+          log.warn('Notification ciblée client ignorée: clientId manquant');
+          return;
+        }
+        services.getServer().io.to(clientId).emit('notification', payload);
+        return;
+      }
+
+      services.getServer().io.emit('notification', payload);
+    },
+  };
+}

package/server/services/notifier/createHostNotifier.js

@@ -0,0 +1,41 @@
+import {createHostNotifierByPlatform} from './host-notifier/index.js';
+import {en} from '../../../client/i18n/locales/en.js';
+import {fr} from '../../../client/i18n/locales/fr.js';
+
+function interpolate(template, params = {}) {
+    return String(template || '').replace(/\{(\w+)\}/g, (_match, key) => String(params[key] ?? ''));
+}
+
+function getHostNotificationDictionary() {
+    return String(process.env.LANG || '').toLowerCase().startsWith('fr') ? fr : en;
+}
+
+function translateNotificationPayload(payload = {}) {
+    const dictionary = getHostNotificationDictionary();
+    const params = payload.params && typeof payload.params === 'object' ? payload.params : {};
+    const titleTemplate = payload.titleKey ? dictionary[payload.titleKey] : '';
+    const messageTemplate = payload.messageKey ? dictionary[payload.messageKey] : '';
+
+    return {
+        ...payload,
+        title: titleTemplate ? interpolate(titleTemplate, params) : payload.title,
+        message: messageTemplate ? interpolate(messageTemplate, params) : payload.message,
+    };
+}
+
+export function createHostNotifier(services) {
+    let platformNotifier = null;
+
+    function getPlatformNotifier() {
+        if (!platformNotifier) {
+            platformNotifier = createHostNotifierByPlatform();
+        }
+        return platformNotifier;
+    }
+
+    return {
+        notify(payload) {
+            getPlatformNotifier().notify(translateNotificationPayload(payload));
+        },
+    };
+}

package/server/services/notifier/createNotifier.js

@@ -0,0 +1,13 @@
+import { createClientNotifier } from './createClientNotifier.js';
+import { createHostNotifier } from './createHostNotifier.js';
+import { createNotifierComposite } from './createNotifierComposite.js';
+
+export function createNotifier(services) {
+  const clientNotifier = createClientNotifier(services);
+  const serverNotifier = createHostNotifier(services);
+  return createNotifierComposite({
+    clientNotifier,
+    serverNotifier,
+    getNotificationsConfig: () => services.getConfig().notifications,
+  });
+}

package/server/services/notifier/createNotifierComposite.js

@@ -0,0 +1,122 @@
+import {DEFAULT_PERSISTED_CONFIG} from '../config/defaultConfig.js';
+import {createLogger} from '../../application/logger.js';
+import {
+    isNotificationTargetEnabled,
+    NOTIFICATION_TARGET_CLIENT as CONFIG_NOTIFICATION_TARGET_CLIENT,
+    NOTIFICATION_TARGET_HOST as CONFIG_NOTIFICATION_TARGET_HOST,
+} from '../../../utils/notificationSettings.js';
+
+let log;
+function getModuleLog() {
+    log ??= createLogger('notifier:composite');
+    return log;
+}
+
+export const NOTIFIER_TARGET_ALL = 'all';
+export const NOTIFIER_TARGET_ALL_CLIENTS = 'all-clients';
+export const NOTIFIER_TARGET_CLIENT = 'client';
+export const NOTIFIER_TARGET_SERVER = 'server';
+export const NOTIFIER_TARGET_NONE = 'none';
+export const NOTIFIER_TARGETS = [
+    NOTIFIER_TARGET_ALL,
+    NOTIFIER_TARGET_ALL_CLIENTS,
+    NOTIFIER_TARGET_CLIENT,
+    NOTIFIER_TARGET_SERVER,
+    NOTIFIER_TARGET_NONE,
+];
+export const NOTIFIER_LEVEL_INFO = 'info';
+export const NOTIFIER_LEVEL_WARNING = 'warning';
+export const NOTIFIER_LEVEL_ERROR = 'error';
+export const NOTIFIER_LEVELS = [
+    NOTIFIER_LEVEL_INFO,
+    NOTIFIER_LEVEL_WARNING,
+    NOTIFIER_LEVEL_ERROR,
+];
+
+export function createNotifierComposite({clientNotifier, serverNotifier, getNotificationsConfig}) {
+    const log = getModuleLog();
+    function getDefaultTtlMs() {
+        return getNotificationsConfig?.()?.ttlMs
+            ?? DEFAULT_PERSISTED_CONFIG.notifications.ttlMs;
+    }
+
+    function shouldNotifyTarget(notificationsConfig, notificationId, target) {
+        if (!notificationId) {
+            return true;
+        }
+        return isNotificationTargetEnabled(notificationsConfig, notificationId, target);
+    }
+
+    function createTargetNotifier(selectedTarget) {
+        return {
+            notify({
+                       title = 'Remote Mouse',
+                       notificationId,
+                       titleKey,
+                       message,
+                       messageKey,
+                       params,
+                       level = NOTIFIER_LEVEL_INFO,
+                       ttlMs = getDefaultTtlMs(),
+                   } = {}, options = {}) {
+                if (!message && !messageKey) {
+                    return;
+                }
+
+                const safeTtlMs = Math.max(500, Math.round(ttlMs));
+                const payload = {
+                    title,
+                    titleKey,
+                    message,
+                    messageKey,
+                    params,
+                    level,
+                    ttlMs: safeTtlMs,
+                    createdAt: Date.now(),
+                };
+
+                const resolvedTarget = String(selectedTarget ?? NOTIFIER_TARGET_ALL).toLowerCase();
+                const clientId = options.clientId;
+                const notificationsConfig = getNotificationsConfig?.() || DEFAULT_PERSISTED_CONFIG.notifications;
+                const shouldNotifyClient = shouldNotifyTarget(
+                    notificationsConfig,
+                    notificationId,
+                    CONFIG_NOTIFICATION_TARGET_CLIENT,
+                );
+                const shouldNotifyHost = shouldNotifyTarget(
+                    notificationsConfig,
+                    notificationId,
+                    CONFIG_NOTIFICATION_TARGET_HOST,
+                );
+
+                if ((resolvedTarget === NOTIFIER_TARGET_ALL ||
+                    resolvedTarget === NOTIFIER_TARGET_ALL_CLIENTS ||
+                    resolvedTarget === NOTIFIER_TARGET_CLIENT) && clientNotifier && shouldNotifyClient) {
+                    clientNotifier.notify(payload, {
+                        scope: resolvedTarget === NOTIFIER_TARGET_CLIENT ?
+                            NOTIFIER_TARGET_CLIENT : NOTIFIER_TARGET_ALL_CLIENTS,
+                        clientId,
+                    });
+                }
+
+                if ((resolvedTarget === NOTIFIER_TARGET_ALL ||
+                    resolvedTarget === NOTIFIER_TARGET_SERVER) && serverNotifier && shouldNotifyHost) {
+                    serverNotifier.notify(payload);
+                }
+
+                if (!NOTIFIER_TARGETS.includes(resolvedTarget)) {
+                    log.warn({target: resolvedTarget}, 'Target de notification inconnu');
+                }
+            },
+        };
+    }
+
+    return {
+        target(target = NOTIFIER_TARGET_ALL) {
+            return createTargetNotifier(target);
+        },
+        notify(args) {
+            return this.target(args.target).notify(args);
+        }
+    };
+}