@velor/remote-mouse 6.4.8

package/server/services/system/createSystemService.js

@@ -0,0 +1,170 @@
+import os from 'node:os';
+import {getScreenInfo} from "./getScreenInfo.js";
+import {getNetworkInfo} from "./getNetworkInfo.js";
+import {createLogger} from '../../application/logger.js';
+import {BROWSER_CATALOG} from '../../remotes/browser/browserCatalog.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('system');
+  return log;
+}
+
+function getConfigSection(config, key) {
+  return config?.[key] && typeof config[key] === 'object' ? config[key] : {};
+}
+
+function isConfigEnabled(config, key) {
+  return getConfigSection(config, key).enabled !== false;
+}
+
+function buildApplications({browsers, vlcAvailable}) {
+  const installedBrowsers = new Map(
+    browsers.map((browser) => [browser.id, browser]),
+  );
+  const browserApplications = BROWSER_CATALOG.map((browser) => {
+    const installedBrowser = installedBrowsers.get(browser.id);
+    return {
+      id: `browser:${browser.id}`,
+      applicationId: browser.id,
+      name: browser.name,
+      shortLabel: browser.shortLabel,
+      kind: 'browser',
+      available: Boolean(installedBrowser),
+      command: installedBrowser?.command || '',
+      app: installedBrowser?.app || '',
+      remotes: ['browser'],
+    };
+  });
+
+  return [
+    ...browserApplications,
+    {
+      id: 'vlc',
+      applicationId: 'vlc',
+      name: 'VLC media player',
+      shortLabel: 'VLC',
+      kind: 'media-player',
+      available: Boolean(vlcAvailable),
+      remotes: ['vlc'],
+    },
+  ];
+}
+
+function buildRemoteCapabilities({applications, config}) {
+  const availableBrowserApplicationIds = applications
+    .filter((application) => application.kind === 'browser' && application.available)
+    .map((application) => application.id);
+  const hasBrowserApplication = availableBrowserApplicationIds.length > 0;
+  const isVlcAvailable = applications.some(
+    (application) => application.applicationId === 'vlc' && application.available,
+  );
+  const remoteVisibility = [
+    {
+      id: 'browser',
+      labelKey: 'preferences.remote.browser',
+      applicationIds: availableBrowserApplicationIds,
+      available: hasBrowserApplication,
+      enabled: isConfigEnabled(config, 'browser'),
+    },
+    {
+      id: 'keyboard',
+      labelKey: 'preferences.remote.keyboard',
+      applicationIds: [],
+      available: true,
+      enabled: isConfigEnabled(config, 'keyboard'),
+    },
+    {
+      id: 'vlc',
+      labelKey: 'preferences.remote.vlc',
+      applicationIds: isVlcAvailable ? ['vlc'] : [],
+      available: isVlcAvailable,
+      enabled: isConfigEnabled(config, 'vlc'),
+    },
+    {
+      id: 'preview',
+      labelKey: 'preferences.remote.preview',
+      applicationIds: [],
+      available: true,
+      enabled: isConfigEnabled(config, 'preview'),
+    },
+    {
+      id: 'samsung',
+      labelKey: 'preferences.remote.samsung',
+      applicationIds: [],
+      available: true,
+      enabled: Boolean(getConfigSection(config, 'samsungTv').enabled),
+    },
+  ];
+
+  return remoteVisibility.map((remote) => ({
+    ...remote,
+    inactiveReasons: [
+      remote.available ? '' : 'application-unavailable',
+      remote.enabled ? '' : 'config-disabled',
+    ].filter(Boolean),
+  }));
+}
+
+export function createSystemService(services) {
+  const log = getModuleLog();
+  return {
+    listBrowsers() {
+      log.debug('Detection des navigateurs disponibles');
+      return services.getRemotes().browser.listBrowsers();
+    },
+    isVlcAvailable() {
+      log.debug('Detection disponibilite VLC');
+      return services.getRemotes().vlc.isAvailable();
+    },
+    async getScreenInfo() {
+      const screen = await getScreenInfo(services);
+      log.debug({screen}, 'Detection resolution ecran');
+      return screen;
+    },
+    getNetworkInfo() {
+      const network = getNetworkInfo(services);
+      log.debug({
+        lanIp: network.lanIp,
+        publicBaseUrl: network.publicBaseUrl,
+        interfaceCount: network.interfaces.length,
+      }, 'Detection reseau');
+      return network;
+    },
+    async getInfo() {
+      log.debug('Collecte des capacites serveur');
+      const browsers = await this.listBrowsers();
+      const vlcAvailable = await this.isVlcAvailable();
+      const applications = buildApplications({browsers, vlcAvailable});
+      const allRemotes = buildRemoteCapabilities({
+        applications,
+        config: services.getConfig(),
+      });
+      const screen = await this.getScreenInfo();
+      const network = this.getNetworkInfo();
+
+      log.debug({
+        browserCount: browsers.length,
+        vlcAvailable,
+        applicationCount: applications.filter((application) => application.available).length,
+        remoteCount: allRemotes.filter((remote) => remote.available).length,
+        screen,
+        lanIp: network.lanIp,
+      }, 'Capacites serveur collectees');
+
+      return {
+        platform: services.getOs().platform,
+        hostname: os.hostname(),
+        browsers,
+        vlc: {
+          available: vlcAvailable,
+        },
+        applications,
+        remotes: allRemotes.filter((remote) => remote.available),
+        allRemotes,
+        screen,
+        network,
+      };
+    },
+  };
+}

package/server/services/system/getNetworkInfo.js

@@ -0,0 +1,18 @@
+import os from "node:os";
+import {getLanIp} from "../../utils/network.js";
+import {listNetworkInterfaces} from "./listNetworkInterfaces.js";
+
+export function getNetworkInfo(services) {
+    const systemConfig = services.getSystemConfig();
+    const urls = services.getUrls();
+
+    return {
+        hostname: os.hostname(),
+        protocol: String(systemConfig?.protocol || 'http'),
+        port: Number.isFinite(Number(systemConfig?.port)) ? Number(systemConfig.port) : null,
+        lanIp: getLanIp(systemConfig?.host || ''),
+        publicBaseUrl: urls.publicBaseUrl,
+        localBaseUrl: urls.localBaseUrl,
+        interfaces: listNetworkInterfaces(),
+    };
+}

package/server/services/system/getScreenInfo.js

@@ -0,0 +1,32 @@
+import {resolveLinuxScreenSize} from '../../os/linux/screen.js';
+
+function normalizeScreenInfo(screen) {
+    const width = Number(screen?.width);
+    const height = Number(screen?.height);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return null;
+    }
+
+    return {
+        width: Math.round(width),
+        height: Math.round(height),
+    };
+}
+
+export async function getScreenInfo(services) {
+    try {
+        if (services.getOs?.().platform === 'linux') {
+            const linuxScreen = await resolveLinuxScreenSize();
+            if (linuxScreen) {
+                return linuxScreen;
+            }
+        }
+    } catch (_error) {}
+
+    try {
+        const screen = services.getRobot().getScreenSize();
+        return normalizeScreenInfo(screen);
+    } catch (_error) {
+        return null;
+    }
+}

package/server/services/system/listNetworkInterfaces.js

@@ -0,0 +1,27 @@
+import os from "node:os";
+
+export function listNetworkInterfaces() {
+    let interfaces = {};
+    try {
+        interfaces = os.networkInterfaces();
+    } catch (_error) {
+        interfaces = {};
+    }
+    const entries = [];
+
+    for (const [name, addresses] of Object.entries(interfaces)) {
+        for (const address of addresses || []) {
+            entries.push({
+                name,
+                family: String(address.family || ''),
+                address: String(address.address || ''),
+                internal: Boolean(address.internal),
+                mac: String(address.mac || ''),
+                netmask: String(address.netmask || ''),
+                cidr: String(address.cidr || ''),
+            });
+        }
+    }
+
+    return entries;
+}

package/server/services/task-manager/createTaskManager.js

@@ -0,0 +1,68 @@
+import {PUBSUB_SERVICE_TASK_MANAGER} from "../pubsub/serviceEventConstants.js";
+
+function getFixedDelayMs(valueInMinutes) {
+  return Math.max(60_000, Number(valueInMinutes || 0) * 60_000);
+}
+
+export function createTaskManager(services) {
+  let started = false;
+
+  function getTaskRunner() {
+    return services.getTaskRunner();
+  }
+
+  function publishState() {
+    services.getEvents().publishState(PUBSUB_SERVICE_TASK_MANAGER, {
+      tasks: getTaskRunner().getTasksSnapshot(),
+    });
+  }
+
+  function wrapTask(task) {
+    return async () => {
+      try {
+        await task();
+      } finally {
+        publishState();
+      }
+    };
+  }
+
+  async function start() {
+    if (started) {
+      return;
+    }
+
+    started = true;
+    await services.getUpdateManager().check();
+
+    getTaskRunner().run(
+      wrapTask(() => services.getUpdateManager().check()),
+      () => getFixedDelayMs(services.getSystemConfig().updateCheck?.intervalMin || 1),
+      {name: 'update-check'},
+    );
+
+    getTaskRunner().run(
+      wrapTask(() => services.getTokenManager().rotateIfNeeded()),
+      () => getFixedDelayMs(services.getSystemConfig().entryPath?.rotateMin || 0),
+      {name: 'token-rotation'},
+    );
+
+    publishState();
+  }
+
+  function stop() {
+    started = false;
+    getTaskRunner().stopAll();
+    publishState();
+  }
+
+  function getTasksSnapshot() {
+    return getTaskRunner().getTasksSnapshot();
+  }
+
+  return {
+    start,
+    stop,
+    getTasksSnapshot,
+  };
+}

package/server/services/task-runner/createTaskRunner.js

@@ -0,0 +1,114 @@
+export function createTaskRunner() {
+  const stops = new Set();
+  const tasks = new Set();
+  let nextTaskId = 1;
+
+  function normalizeDelay(delay) {
+    const value = Number(delay);
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+
+    return Math.max(0, Math.floor(value));
+  }
+
+  function run(task, delayOrProvider, options = {}) {
+    let timer = null;
+    let stopped = false;
+    const taskState = {
+      id: `task-${nextTaskId++}`,
+      name: typeof options.name === 'string' && options.name.trim() ? options.name.trim() : 'unnamed-task',
+      dueAt: null,
+      delayMs: null,
+      running: false,
+    };
+
+    tasks.add(taskState);
+
+    function getDelayMs() {
+      const rawDelay = typeof delayOrProvider === 'function'
+        ? delayOrProvider()
+        : delayOrProvider;
+      return normalizeDelay(rawDelay);
+    }
+
+    async function loop() {
+      if (stopped) {
+        return;
+      }
+
+      taskState.running = true;
+      taskState.dueAt = null;
+
+      try {
+        await task();
+      } finally {
+        taskState.running = false;
+        schedule();
+      }
+    }
+
+    function schedule() {
+      if (stopped) {
+        return;
+      }
+
+      const delayMs = getDelayMs();
+      taskState.delayMs = delayMs;
+
+      if (delayMs === null) {
+        taskState.dueAt = null;
+        return;
+      }
+
+      taskState.dueAt = new Date(Date.now() + delayMs).toISOString();
+      timer = setTimeout(() => {
+        timer = null;
+        void loop();
+      }, delayMs);
+    }
+
+    function stop() {
+      if (stopped) {
+        return;
+      }
+
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      taskState.dueAt = null;
+      taskState.running = false;
+      tasks.delete(taskState);
+      stops.delete(stop);
+    }
+
+    stops.add(stop);
+    schedule();
+
+    return stop;
+  }
+
+  function stopAll() {
+    for (const stop of Array.from(stops)) {
+      stop();
+    }
+  }
+
+  function getTasksSnapshot() {
+    return Array.from(tasks, (task) => ({
+      id: task.id,
+      name: task.name,
+      dueAt: task.dueAt,
+      delayMs: task.delayMs,
+      running: task.running,
+    }));
+  }
+
+  return {
+    run,
+    stopAll,
+    getTasksSnapshot,
+  };
+}

package/server/services/token-manager/createTokenManager.js

@@ -0,0 +1,244 @@
+import {createRandomToken} from '../../utils/createRandomToken.js';
+import {isTokenFormatValid, normalizeToken} from './token-format.js';
+import {computeTokenTtlMs} from './token-store-utils.js';
+import {
+    PUBSUB_EVENT_STATE_CHANGED,
+    PUBSUB_EVENT_TOKEN_CHANGED,
+    PUBSUB_SERVICE_TOKEN_MANAGER
+} from "../pubsub/serviceEventConstants.js";
+import {createLogger} from '../../application/logger.js';
+
+let log;
+function getModuleLog() {
+    log ??= createLogger('token-manager');
+    return log;
+}
+
+function createTokenPersistence(services) {
+    return {
+        countTokens: () => services.getPersistence().entryTokenDao.countEntryTokens(),
+        deleteExpiredTokens: (options) => services.getPersistence().entryTokenDao.deleteExpiredEntryTokens(options),
+        getLatestToken: () => services.getPersistence().entryTokenDao.getLatestEntryToken(),
+        getLatestTokenRecord: () => services.getPersistence().entryTokenDao.getLatestEntryTokenRecord?.(),
+        hasToken: (token) => services.getPersistence().entryTokenDao.hasEntryToken(token),
+        createToken: (token, createdAt) => services.getPersistence().entryTokenDao.createEntryToken(token, createdAt),
+    };
+}
+
+export function createTokenManager(services) {
+    const log = getModuleLog();
+    const persistence = createTokenPersistence(services);
+
+    function publishState(type = PUBSUB_EVENT_STATE_CHANGED) {
+        const latestToken = getLatestTokenRecord();
+        const nextRotationDelayMs = !isPersistenceEnabled()
+            ? null
+            : !latestToken
+                ? 0
+                : Math.max(0, latestToken.createdAt + getRotateTtlMs() - Date.now());
+
+        log.trace({
+            type,
+            enabled: isEffectivelyEnabled(),
+            gateEnabled: isGateEnabled(),
+            persistenceEnabled: isPersistenceEnabled(),
+            hasCurrentToken: Boolean(getCurrentToken()),
+            tokenCount: loadTokens(),
+            nextRotationDelayMs,
+        }, 'Publication etat token manager');
+
+        services.getEvents().publishState(PUBSUB_SERVICE_TOKEN_MANAGER, {
+            enabled: isEffectivelyEnabled(),
+            gateEnabled: isGateEnabled(),
+            persistenceEnabled: isPersistenceEnabled(),
+            token: getCurrentToken() || '',
+            tokenCount: loadTokens(),
+            nextRotationDelayMs,
+        }, {type});
+    }
+
+    function getEntryPathConfig() {
+        return services.getSystemConfig().entryPath;
+    }
+
+    function getNormalizedFixedPath() {
+        return normalizeToken(getEntryPathConfig().fixed);
+    }
+
+    function isEffectivelyEnabled() {
+        return Boolean(getEntryPathConfig().enabled);
+    }
+
+    function isGateEnabled() {
+        return isEffectivelyEnabled() || Boolean(getNormalizedFixedPath());
+    }
+
+    function isPersistenceEnabled() {
+        return isEffectivelyEnabled() && !getNormalizedFixedPath();
+    }
+
+    function readCurrentToken() {
+        const normalizedFixedPath = getNormalizedFixedPath();
+        if (normalizedFixedPath) {
+            return normalizedFixedPath;
+        }
+        if (!isPersistenceEnabled()) {
+            return '';
+        }
+        const token = normalizeToken(persistence.getLatestToken?.());
+        return isTokenFormatValid(token) ? token : '';
+    }
+
+    function getCurrentToken() {
+        return readCurrentToken();
+    }
+
+    function getRotateTtlMs() {
+        return Math.max(60_000, Number(getEntryPathConfig().rotateMin || 0) * 60_000);
+    }
+
+    function getLatestTokenRecord() {
+        const record = persistence.getLatestTokenRecord?.() || (() => {
+            const token = normalizeToken(persistence.getLatestToken?.());
+            return token ? {token, createdAt: Number.NaN} : null;
+        })();
+        const token = normalizeToken(record?.token);
+        const createdAt = Math.floor(Number(record?.createdAt));
+
+        if (!isTokenFormatValid(token)) {
+            return null;
+        }
+
+        if (!Number.isFinite(createdAt)) {
+            return {token, createdAt: Number.NaN};
+        }
+
+        return {
+            token,
+            createdAt,
+        };
+    }
+
+    function loadTokens() {
+        if (!isPersistenceEnabled()) {
+            return 0;
+        }
+        return Number(persistence.countTokens?.() || 0);
+    }
+
+    function cleanupExpired({persist = false} = {}) {
+        const normalizedFixedPath = getNormalizedFixedPath();
+        if (!isGateEnabled() || normalizedFixedPath) {
+            log.trace({
+                persist,
+                gateEnabled: isGateEnabled(),
+                fixedPathEnabled: Boolean(normalizedFixedPath),
+            }, 'Nettoyage tokens expire ignores');
+            return;
+        }
+        if (persist) {
+            const graceTtlMs = computeTokenTtlMs(getEntryPathConfig().graceMin);
+            log.debug({graceTtlMs}, 'Nettoyage tokens expires');
+            persistence.deleteExpiredTokens({
+                olderThan: Date.now() - graceTtlMs,
+                keepToken: getCurrentToken(),
+            });
+        }
+    }
+
+    function createToken() {
+        const normalizedFixedPath = getNormalizedFixedPath();
+        const currentToken = getCurrentToken();
+        if (!isEffectivelyEnabled() || normalizedFixedPath) {
+            log.trace({
+                enabled: isEffectivelyEnabled(),
+                fixedPathEnabled: Boolean(normalizedFixedPath),
+                hasCurrentToken: Boolean(currentToken),
+            }, 'Creation token ignoree');
+            return currentToken;
+        }
+        const createdAt = Date.now();
+        const token = createRandomToken(getEntryPathConfig().tokenLength);
+
+        log.debug({tokenLength: token.length}, 'Creation nouveau token entree');
+        persistence.createToken(token, createdAt);
+        cleanupExpired({persist: true});
+        if (token !== currentToken) {
+            publishState(PUBSUB_EVENT_TOKEN_CHANGED);
+        }
+        return token;
+    }
+
+    function isValid(token) {
+        const normalizedFixedPath = getNormalizedFixedPath();
+        const currentToken = getCurrentToken();
+        const normalized = normalizeToken(token);
+        if (normalizedFixedPath) {
+            log.trace({
+                mode: 'fixed',
+                hasInputToken: Boolean(normalized),
+            }, 'Validation token entree');
+            if (!normalized) {
+                return false;
+            }
+            return normalized === currentToken;
+        }
+        if (!isGateEnabled()) {
+            log.trace({
+                mode: 'disabled',
+                hasCurrentToken: Boolean(currentToken),
+                hasInputToken: Boolean(normalized),
+            }, 'Validation token entree');
+            if (!currentToken) {
+                return true;
+            }
+            if (!normalized) {
+                return false;
+            }
+            return normalized === currentToken;
+        }
+        if (!normalized) {
+            log.trace('Validation token entree rejetee: token vide');
+            return false;
+        }
+        cleanupExpired({persist: true});
+        if (!isPersistenceEnabled()) {
+            log.trace('Validation token entree rejetee: persistence inactive');
+            return false;
+        }
+        log.trace('Validation token entree via persistence');
+        return Boolean(persistence.hasToken(normalized));
+    }
+
+    function rotateIfNeeded() {
+        if (!isPersistenceEnabled()) {
+            log.trace('Rotation token ignoree: persistence inactive');
+            return getCurrentToken();
+        }
+
+        const latestToken = getLatestTokenRecord();
+        if (!latestToken) {
+            log.debug('Rotation token: aucun token existant');
+            return createToken();
+        }
+
+        if (!Number.isFinite(latestToken.createdAt) || Date.now() < latestToken.createdAt + getRotateTtlMs()) {
+            log.trace({
+                hasCreatedAt: Number.isFinite(latestToken.createdAt),
+            }, 'Rotation token non requise');
+            return latestToken.token;
+        }
+
+        log.debug('Rotation token requise');
+        return createToken();
+    }
+    
+    return {
+        isValid,
+        createToken,
+        cleanupExpired,
+        loadTokens,
+        getToken: getCurrentToken,
+        rotateIfNeeded,
+    };
+}

package/server/services/token-manager/token-format.js

@@ -0,0 +1,7 @@
+export function normalizeToken(value) {
+  return String(value || '').replace(/^\/+|\/+$/g, '');
+}
+
+export function isTokenFormatValid(token) {
+  return /^[A-Za-z0-9_-]{8,128}$/.test(String(token || ''));
+}

package/server/services/token-manager/token-store-utils.js

@@ -0,0 +1,8 @@
+export function computeTokenTtlMs(graceMin) {
+  const value = Number(graceMin);
+  if (!Number.isFinite(value)) {
+    throw new Error('entryPath.graceMin must be a finite number');
+  }
+
+  return Math.max(60_000, value * 60_000);
+}