@velor/remote-mouse 6.4.8

package/server/services/config/configSchema.js

@@ -0,0 +1,297 @@
+import { getNotificationPaths } from '../../../utils/notificationSettings.js';
+import { BROWSER_CATALOG } from '../../remotes/browser/browserCatalog.js';
+
+const BROWSER_CONFIG_FIELDS = Object.fromEntries(
+  BROWSER_CATALOG.map((browser) => [browser.id, {
+    label: browser.name,
+    type: 'boolean',
+  }]),
+);
+
+export const CONFIG_SCHEMA = {
+  input: {
+    title: 'Souris et entree',
+    description: 'Parametres de sensibilite pour le pointeur et le scroll.',
+    fields: {
+      mouseSpeed: {
+        label: 'Vitesse souris',
+        type: 'number',
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+      },
+      scrollSpeed: {
+        label: 'Vitesse scroll',
+        type: 'number',
+        min: 0.05,
+        max: 5,
+        step: 0.05,
+      },
+      touchDragHoldMs: {
+        label: 'Delai drag tactile (ms)',
+        type: 'integer',
+        min: 100,
+        max: 1500,
+        step: 10,
+      },
+      touchDragStillDistancePx: {
+        label: 'Tolerance immobile drag tactile (px)',
+        type: 'integer',
+        min: 1,
+        max: 40,
+        step: 1,
+      },
+    },
+  },
+  browser: {
+    title: 'Navigateur',
+    description: 'Active ou masque la remote navigateur pour tous les clients.',
+    fields: {
+      enabled: {
+        label: 'Activer la remote navigateur',
+        type: 'boolean',
+      },
+      ...BROWSER_CONFIG_FIELDS,
+    },
+  },
+  keyboard: {
+    title: 'Clavier',
+    description: 'Active ou masque la remote clavier pour tous les clients.',
+    fields: {
+      enabled: {
+        label: 'Activer la remote clavier',
+        type: 'boolean',
+      },
+    },
+  },
+  vlc: {
+    title: 'VLC',
+    description: 'Active ou masque la remote VLC pour tous les clients.',
+    fields: {
+      enabled: {
+        label: 'Activer la remote VLC',
+        type: 'boolean',
+      },
+    },
+  },
+  preview: {
+    title: 'Apercu curseur',
+    description: "Qualite et cadence de l'apercu diffuse au client.",
+    fields: {
+      enabled: {
+        label: 'Activer le preview curseur',
+        type: 'boolean',
+      },
+      width: {
+        label: 'Largeur',
+        type: 'integer',
+        min: 32,
+        max: 512,
+        step: 1,
+      },
+      height: {
+        label: 'Hauteur',
+        type: 'integer',
+        min: 24,
+        max: 512,
+        step: 1,
+      },
+      fps: {
+        label: 'FPS',
+        type: 'integer',
+        min: 1,
+        max: 30,
+        step: 1,
+      },
+      hideDelayMs: {
+        label: 'Delai de masque (ms)',
+        type: 'integer',
+        min: 200,
+        max: 60000,
+        step: 100,
+      },
+    },
+  },
+  notifications: {
+    title: 'Notifications',
+    description: 'Reglage des notifications par evenement pour le host et le client.',
+    fields: {
+      ttlMs: {
+        label: 'Duree affichage (ms)',
+        type: 'integer',
+        min: 500,
+        max: 10000,
+        step: 100,
+      },
+    },
+  },
+  samsungTv: {
+    title: 'Samsung TV',
+    description: 'Connexion, delais et raccourcis pour la TV Samsung.',
+    fields: {
+      enabled: {
+        label: 'Activer Samsung TV',
+        type: 'boolean',
+      },
+      alwaysAutoResolve: {
+        label: 'Toujours auto-resoudre',
+        type: 'boolean',
+      },
+      host: {
+        label: 'Adresse IP',
+        type: 'string',
+        placeholder: '192.168.1.50',
+      },
+      mac: {
+        label: 'Adresse MAC',
+        type: 'string',
+        placeholder: 'AA:BB:CC:DD:EE:FF',
+      },
+      port: {
+        label: 'Port',
+        type: 'integer',
+        min: 1,
+        max: 65535,
+        step: 1,
+      },
+      appName: {
+        label: 'Nom application',
+        type: 'string',
+        placeholder: 'Remote Mouse',
+      },
+      discoveryTimeoutMs: {
+        label: 'Timeout decouverte (ms)',
+        type: 'integer',
+        min: 100,
+        max: 20000,
+        step: 100,
+      },
+      timeoutMs: {
+        label: 'Timeout commande (ms)',
+        type: 'integer',
+        min: 500,
+        max: 60000,
+        step: 100,
+      },
+      pcInputKey: {
+        label: 'Touche entree PC',
+        type: 'string',
+        placeholder: 'KEY_HDMI1',
+      },
+      pcInputSequence: {
+        label: 'Sequence entree PC',
+        type: 'string',
+        placeholder: 'KEY_SOURCE,KEY_DOWN,KEY_ENTER',
+      },
+      powerOffKey: {
+        label: 'Touche extinction',
+        type: 'string',
+        placeholder: 'KEY_POWER',
+      },
+    },
+  },
+  updateCheck: {
+    title: 'Mises a jour',
+    description: 'Activation de la verification automatique des mises a jour.',
+    fields: {
+      enabled: {
+        label: 'Activer la verification',
+        type: 'boolean',
+      },
+    },
+  },
+  qrOverlay: {
+    title: 'QR Overlay',
+    description: "Reglage de taille et de position de l'overlay QR.",
+    fields: {
+      enabled: {
+        label: "Afficher l'overlay",
+        type: 'boolean',
+      },
+      size: {
+        label: 'Taille',
+        type: 'integer',
+        min: 24,
+        max: 400,
+        step: 1,
+      },
+      margin: {
+        label: 'Marge',
+        type: 'integer',
+        min: 0,
+        max: 200,
+        step: 1,
+      },
+      topOffsetPx: {
+        label: 'Offset haut (px)',
+        type: 'integer',
+        min: 0,
+        max: 500,
+        step: 1,
+      },
+      autoHideOnHover: {
+        label: 'Masquage auto au survol',
+        type: 'boolean',
+      },
+      hoverEntryMarginPx: {
+        label: "Marge d'entree hover (px)",
+        type: 'integer',
+        min: 0,
+        max: 100,
+        step: 1,
+      },
+      hoverExitMarginPx: {
+        label: 'Marge de sortie hover (px)',
+        type: 'integer',
+        min: 0,
+        max: 150,
+        step: 1,
+      },
+      hoverShowDelayMs: {
+        label: 'Delai de reaffichage hover (ms)',
+        type: 'integer',
+        min: 0,
+        max: 10000,
+        step: 50,
+      },
+    },
+  },
+};
+
+export function getManagedConfigSchema(managedPaths = []) {
+  const allowed = new Set(managedPaths);
+  const sections = {};
+
+  for (const [sectionKey, section] of Object.entries(CONFIG_SCHEMA)) {
+    const fields = Object.fromEntries(
+      Object.entries(section.fields).filter(([fieldKey]) => allowed.has(`${sectionKey}.${fieldKey}`)),
+    );
+
+    if (!Object.keys(fields).length) {
+      continue;
+    }
+
+    sections[sectionKey] = {
+      ...section,
+      fields,
+    };
+  }
+
+  return sections;
+}
+
+const CONFIG_FIELD_DEFINITIONS = new Map();
+
+for (const [sectionKey, section] of Object.entries(CONFIG_SCHEMA)) {
+  for (const [fieldKey, field] of Object.entries(section.fields)) {
+    CONFIG_FIELD_DEFINITIONS.set(`${sectionKey}.${fieldKey}`, field);
+  }
+}
+
+for (const pathKey of getNotificationPaths()) {
+  CONFIG_FIELD_DEFINITIONS.set(pathKey, { type: 'boolean' });
+}
+
+export function getConfigFieldDefinition(pathKey) {
+  return CONFIG_FIELD_DEFINITIONS.get(String(pathKey || '').trim()) || null;
+}

package/server/services/config/configService.js

@@ -0,0 +1,89 @@
+import {deepMerge, setNestedValue} from '../../../utils/object.utils.js';
+import {CONFIG_PATHS} from './configPaths.js';
+import {DEFAULT_PERSISTED_CONFIG} from './defaultConfig.js';
+import {
+  PUBSUB_EVENT_CONFIG_DELETED,
+  PUBSUB_EVENT_CONFIG_UPDATED,
+  PUBSUB_SERVICE_CONFIG,
+} from '../pubsub/serviceEventConstants.js';
+
+function isManagedPath(pathKey) {
+  return CONFIG_PATHS.includes(pathKey);
+}
+
+function getValueAtPath(source, dottedPath) {
+  return String(dottedPath || '')
+    .split('.')
+    .filter(Boolean)
+    .reduce((cursor, segment) => (cursor == null ? undefined : cursor[segment]), source);
+}
+
+function mapStoredRowsToObject(rows) {
+  const config = {};
+
+  for (const row of rows || []) {
+    if (!row?.key || !isManagedPath(row.key)) {
+      continue;
+    }
+
+    setNestedValue(config, row.key, row.value);
+  }
+
+  return config;
+}
+
+export function createConfigService(services) {
+  function getStoredConfigObject() {
+    const rows = services.getPersistence().configDao.getAll();
+    return mapStoredRowsToObject(rows);
+  }
+
+  function publishChange(changeType, changedKeys) {
+    const uniqueChangedKeys = Array.from(new Set(changedKeys));
+    services.getPubSub().publish(PUBSUB_SERVICE_CONFIG, {
+      changeType,
+      changedKeys: uniqueChangedKeys,
+      storedConfig: getStoredConfigObject(),
+    }, {
+      type: changeType === 'deleted' ? PUBSUB_EVENT_CONFIG_DELETED : PUBSUB_EVENT_CONFIG_UPDATED,
+      snapshot: false,
+    });
+  }
+
+  return {
+    getConfigs() {
+      return deepMerge(DEFAULT_PERSISTED_CONFIG, getStoredConfigObject());
+    },
+    getConfig(pathKey) {
+      const normalizedPath = String(pathKey || '').trim();
+      if (!normalizedPath) {
+        return undefined;
+      }
+
+      return getValueAtPath(this.getConfigs(), normalizedPath);
+    },
+    setConfig(pathKey, value) {
+      const normalizedPath = String(pathKey || '').trim();
+      if (!isManagedPath(normalizedPath)) {
+        throw new Error(`Invalid config path: ${normalizedPath || '(empty)'}`);
+      }
+
+      services.getPersistence().configDao.saveOne(normalizedPath, value);
+      publishChange('updated', [normalizedPath]);
+      return this.getConfig(normalizedPath);
+    },
+    resetConfig(pathKey) {
+      const normalizedPath = String(pathKey || '').trim();
+      if (!isManagedPath(normalizedPath)) {
+        throw new Error(`Invalid config path: ${normalizedPath || '(empty)'}`);
+      }
+
+      const changes = services.getPersistence().configDao.deleteOne(normalizedPath);
+      if (changes > 0) {
+        publishChange('deleted', [normalizedPath]);
+      }
+
+      return this.getConfig(normalizedPath);
+    },
+  };
+}

package/server/services/config/defaultConfig.js

@@ -0,0 +1,137 @@
+import {
+    packageJson
+} from "./bootstrapConfig.js";
+import { BROWSER_CATALOG } from '../../remotes/browser/browserCatalog.js';
+import {
+    createDefaultNotificationSettings,
+    NOTIFICATION_ID_UPDATE_AVAILABLE,
+    NOTIFICATION_ID_UPDATE_INSTALL,
+    NOTIFICATION_ID_SERVICE_RESTARTED,
+    NOTIFICATION_ID_SERVICE_RESTARTING,
+    NOTIFICATION_ID_SESSION_CREATED,
+} from '../../../utils/notificationSettings.js';
+
+const DEFAULT_NOTIFICATION_SETTINGS = createDefaultNotificationSettings(false);
+
+DEFAULT_NOTIFICATION_SETTINGS[NOTIFICATION_ID_SERVICE_RESTARTING] = {
+    host: true,
+    client: true,
+};
+DEFAULT_NOTIFICATION_SETTINGS[NOTIFICATION_ID_SESSION_CREATED] = {
+    host: true,
+    client: true,
+};
+DEFAULT_NOTIFICATION_SETTINGS[NOTIFICATION_ID_SERVICE_RESTARTED] = {
+    host: true,
+    client: true,
+};
+DEFAULT_NOTIFICATION_SETTINGS[NOTIFICATION_ID_UPDATE_INSTALL] = {
+    host: true,
+    client: true,
+};
+DEFAULT_NOTIFICATION_SETTINGS[NOTIFICATION_ID_UPDATE_AVAILABLE] = {
+    host: true,
+    client: true,
+};
+
+const DEFAULT_BROWSER_CONFIG = Object.fromEntries(
+    BROWSER_CATALOG.map((browser) => [browser.id, true]),
+);
+
+export const DEFAULT_SYSTEM_CONFIG = {
+    port: 3000,
+    serverHost: '',
+    entryPath: {
+        enabled: true,
+        fixed: '',
+        tokenLength: 24,
+        rotateMin: 60,
+        graceMin: 60 * 24 * 7, // 1 semaine de grâce
+    },
+    session: {
+        cookieName: 'remote_mouse_session',
+        cookieSecret: 'change-me',
+        cookieMaxAgeDays: 7,
+        socketEventMaxAgeMs: 1200,
+    },
+    adminActionsEnabled: true,
+    serviceName: 'remote-mouse.service',
+    serviceRestartCommand: '',
+    updateCheck: {
+        checkCommand: '',
+        checkTimeoutSec: 20,
+        intervalMin: 360,
+        packageName: String(packageJson.name || '').trim(),
+        currentVersion: String(packageJson.version || '').trim(),
+        installCommand: '',
+        installTimeoutSec: 600,
+    },
+    https: {
+        enabled: false,
+        sslKeyPath: undefined,
+        sslCertPath: undefined,
+    },
+    persistence: {
+        dbPath: './data/remote-mouse.db',
+    },
+    logging: {
+        level: 'info',
+        format: 'json',
+    },
+};
+
+export const DEFAULT_PERSISTED_CONFIG = {
+    input: {
+        mouseSpeed: 1.3,
+        scrollSpeed: 0.25,
+        touchDragHoldMs: 420,
+        touchDragStillDistancePx: 8,
+    },
+    browser: {
+        enabled: true,
+        ...DEFAULT_BROWSER_CONFIG,
+    },
+    keyboard: {
+        enabled: true,
+    },
+    vlc: {
+        enabled: false,
+    },
+    preview: {
+        enabled: true,
+        width: 128,
+        height: 84,
+        fps: 6,
+        hideDelayMs: 10000,
+    },
+    notifications: {
+        ttlMs: 2200,
+        ...DEFAULT_NOTIFICATION_SETTINGS,
+    },
+    samsungTv: {
+        enabled: false,
+        alwaysAutoResolve: true,
+        host: '',
+        mac: '',
+        port: 8002,
+        appName: 'Remote Mouse',
+        discoveryTimeoutMs: 2500,
+        timeoutMs: 5000,
+        pcInputKey: 'KEY_HDMI1',
+        pcInputSequence: '',
+        powerOffKey: 'KEY_POWER',
+    },
+    updateCheck: {
+        enabled: false,
+    },
+    qrOverlay: {
+        enabled: true,
+        size: 75,
+        margin: 14,
+        topOffsetPx: 32,
+        autoHideOnHover: true,
+        hoverEntryMarginPx: 10,
+        hoverExitMarginPx: 18,
+        hoverShowDelayMs: 5000
+    },
+};

package/server/services/config/envConfig.js

@@ -0,0 +1,49 @@
+import {
+    readOptionalBoolean,
+    readOptionalNumber,
+    readOptionalString
+} from "../../utils/env.js";
+
+export function getEnvConfig() {
+    return {
+        port: readOptionalNumber('PORT'),
+        serverHost: readOptionalString('SERVER_HOST'),
+        entryPath: {
+            enabled: readOptionalBoolean('ENTRY_PATH_ENABLED'),
+            fixed: readOptionalString('ENTRY_PATH_FIXED'),
+            tokenLength: readOptionalNumber('ENTRY_PATH_TOKEN_LENGTH'),
+            rotateMin: readOptionalNumber('ENTRY_PATH_ROTATE_INTERVAL_MIN'),
+            graceMin: readOptionalNumber('ENTRY_PATH_GRACE_MIN'),
+        },
+        session: {
+            cookieName: readOptionalString('SESSION_COOKIE_NAME'),
+            cookieSecret: readOptionalString('SESSION_COOKIE_SECRET'),
+            cookieMaxAgeDays: readOptionalNumber('SESSION_COOKIE_MAX_AGE_DAYS'),
+            socketEventMaxAgeMs: readOptionalNumber('SOCKET_EVENT_MAX_AGE_MS'),
+        },
+        adminActionsEnabled: readOptionalBoolean('ADMIN_ACTIONS_ENABLED'),
+        serviceName: readOptionalString('SERVICE_NAME'),
+        serviceRestartCommand: readOptionalString('SERVICE_RESTART_COMMAND'),
+        https: {
+            enabled: readOptionalBoolean('HTTPS'),
+            sslKeyPath: readOptionalString('SSL_KEY_PATH'),
+            sslCertPath: readOptionalString('SSL_CERT_PATH'),
+        },
+        updateCheck: {
+            checkCommand: readOptionalString('UPDATE_CHECK_COMMAND'),
+            checkTimeoutSec: readOptionalNumber('UPDATE_CHECK_TIMEOUT_SEC'),
+            intervalMin: readOptionalNumber('UPDATE_CHECK_INTERVAL_MIN'),
+            packageName: readOptionalString('UPDATE_CHECK_PACKAGE'),
+            currentVersion: readOptionalString('UPDATE_CHECK_CURRENT_VERSION'),
+            installCommand: readOptionalString('UPDATE_INSTALL_COMMAND'),
+            installTimeoutSec: readOptionalNumber('UPDATE_INSTALL_TIMEOUT_SEC'),
+        },
+        persistence: {
+            dbPath: readOptionalString('PERSISTENCE_DB_PATH'),
+        },
+        logging: {
+            level: readOptionalString('LOG_LEVEL'),
+            format: readOptionalString('LOG_FORMAT'),
+        },
+    };
+}

package/server/services/config/index.js

@@ -0,0 +1,9 @@
+import {
+    getStartupSystemConfigSnapshot,
+    getSystemConfig,
+} from './system-config.js';
+
+export {
+    getStartupSystemConfigSnapshot,
+    getSystemConfig,
+};

package/server/services/config/logConfig.js

@@ -0,0 +1,54 @@
+function emitConfigLine(logger, message, fields = {}) {
+    if (logger && typeof logger.info === 'function') {
+        logger.info(fields, message);
+        return;
+    }
+    console.log(`${message} ${JSON.stringify(fields)}`);
+}
+
+export function logStartupConfig(logger, config) {
+    const systemConfig = config.systemConfig;
+    const persistedConfig = config.config;
+
+    emitConfigLine(logger, 'Configuration');
+    emitConfigLine(logger, 'config.network', {
+        protocol: systemConfig.protocol,
+        port: systemConfig.port,
+        serverHost: systemConfig.serverHost || '(auto LAN detection)',
+    });
+    emitConfigLine(logger, 'config.entryPath', {
+        ...systemConfig.entryPath,
+        fixed: systemConfig.entryPath.fixed || '(random)',
+    });
+    emitConfigLine(logger, 'config.session', {
+        ...systemConfig.session,
+        cookieSecret: undefined,
+    });
+    emitConfigLine(logger, 'config.input', persistedConfig.input);
+    emitConfigLine(logger, 'config.preview', persistedConfig.preview);
+    emitConfigLine(logger, 'config.notifications', persistedConfig.notifications);
+    emitConfigLine(logger, 'config.admin', {
+        adminActionsEnabled: systemConfig.adminActionsEnabled,
+        serviceName: systemConfig.serviceName,
+    });
+    emitConfigLine(logger, 'config.samsungTv', {
+        ...persistedConfig.samsungTv,
+        mac: persistedConfig.samsungTv.mac ? '(set)' : '(unset)',
+    });
+    emitConfigLine(logger, 'config.update', {
+        ...systemConfig.updateCheck,
+        ...persistedConfig.updateCheck,
+        packageName: systemConfig.updateCheck.packageName || '(none)',
+        currentVersion: systemConfig.updateCheck.currentVersion || '(none)',
+        installCommand: systemConfig.updateCheck.installCommand || '(unset)',
+    });
+    emitConfigLine(logger, 'config.qrOverlay', persistedConfig.qrOverlay);
+    emitConfigLine(logger, 'config.runtime', {
+        graphicalDisplay: systemConfig.graphicalDisplay,
+        https: {
+            ...systemConfig.https,
+            sslKeyPath: systemConfig.https.enabled ? (systemConfig.https.sslKeyPath || '(missing)') : undefined,
+            sslCertPath: systemConfig.https.enabled ? (systemConfig.https.sslCertPath || '(missing)') : undefined,
+        },
+    });
+}

package/server/services/config/system-config.js

@@ -0,0 +1,44 @@
+import {
+  readString,
+  resolvePathFromConfigDir,
+} from '../../utils/env.js';
+import {deepMerge} from '../../../utils/object.utils.js';
+import {CONFIG_DIR} from './bootstrapConfig.js';
+import {DEFAULT_SYSTEM_CONFIG} from './defaultConfig.js';
+import {getEnvConfig as readEnvConfig} from './envConfig.js';
+
+export function normalizeSystemConfig(defaultSystemConfig) {
+  const httpsEnabled = Boolean(defaultSystemConfig?.https?.enabled);
+
+  return {
+    ...defaultSystemConfig,
+    protocol: httpsEnabled ? 'https' : 'http',
+    entryPath: {
+      ...defaultSystemConfig.entryPath,
+      enabled: Boolean(defaultSystemConfig.entryPath.enabled || defaultSystemConfig.entryPath.fixed),
+    },
+    session: {
+      ...defaultSystemConfig.session,
+      cookieSecure: httpsEnabled,
+      cookieSecretSet: defaultSystemConfig.session.cookieSecret !== 'change-me',
+    },
+    https: {
+      ...defaultSystemConfig.https,
+      sslKeyPath: httpsEnabled ? defaultSystemConfig.https.sslKeyPath : undefined,
+      sslCertPath: httpsEnabled ? defaultSystemConfig.https.sslCertPath : undefined,
+    },
+    persistence: {
+      ...defaultSystemConfig.persistence,
+      dbPath: resolvePathFromConfigDir(defaultSystemConfig.persistence.dbPath, CONFIG_DIR),
+    },
+    graphicalDisplay: Boolean(readString('DISPLAY') || readString('WAYLAND_DISPLAY')),
+  };
+}
+
+export function getStartupSystemConfigSnapshot() {
+  return deepMerge(DEFAULT_SYSTEM_CONFIG, readEnvConfig());
+}
+
+export function getSystemConfig() {
+  return normalizeSystemConfig(getStartupSystemConfigSnapshot());
+}