@velor/remote-mouse 6.4.8

package/server/services/persistence/createRestartLogDao.js

@@ -0,0 +1,210 @@
+const RESTART_LOG_TABLE = 'application_restart_log';
+
+const DEFAULT_RESTART_CAUSE = 'user';
+const DEFAULT_EVENT_TYPE = 'restart';
+
+function normalizeRestartCause(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'user' || normalized === 'reboot' || normalized === 'unexpected') {
+    return normalized;
+  }
+  return DEFAULT_RESTART_CAUSE;
+}
+
+function normalizeEventType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'start' || normalized === 'stop' || normalized === 'restart') {
+    return normalized;
+  }
+  return DEFAULT_EVENT_TYPE;
+}
+
+function normalizeRecord(row) {
+  if (!row) {
+    return null;
+  }
+
+  let details = {};
+  try {
+    details = JSON.parse(String(row.details_json || '{}'));
+  } catch (_error) {
+    details = {};
+  }
+
+  return {
+    id: Number(row.id),
+    requestedAt: Number(row.requested_at),
+    detectedAt: Number(row.detected_at || 0) || null,
+    eventType: normalizeEventType(row.event_type),
+    cause: normalizeRestartCause(row.restart_cause),
+    source: String(row.source || ''),
+    status: String(row.status || ''),
+    details,
+  };
+}
+
+export function createRestartLogDao({getDatabase}) {
+  let bootstrapped = false;
+
+  function bootstrapRestartLogTable() {
+    if (bootstrapped) {
+      return;
+    }
+
+    const db = getDatabase();
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS ${RESTART_LOG_TABLE} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        requested_at INTEGER NOT NULL,
+        detected_at INTEGER,
+        event_type TEXT NOT NULL DEFAULT '${DEFAULT_EVENT_TYPE}',
+        restart_cause TEXT NOT NULL DEFAULT '${DEFAULT_RESTART_CAUSE}',
+        source TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'requested',
+        details_json TEXT NOT NULL DEFAULT '{}'
+      )
+    `);
+
+    const columns = db.prepare(`PRAGMA table_info(${RESTART_LOG_TABLE})`).all();
+    const hasRestartCause = columns.some((column) => String(column?.name || '') === 'restart_cause');
+    const hasEventType = columns.some((column) => String(column?.name || '') === 'event_type');
+    if (!hasEventType) {
+      db.exec(`
+        ALTER TABLE ${RESTART_LOG_TABLE}
+        ADD COLUMN event_type TEXT NOT NULL DEFAULT '${DEFAULT_EVENT_TYPE}'
+      `);
+    }
+
+    if (!hasRestartCause) {
+      db.exec(`
+        ALTER TABLE ${RESTART_LOG_TABLE}
+        ADD COLUMN restart_cause TEXT NOT NULL DEFAULT '${DEFAULT_RESTART_CAUSE}'
+      `);
+    }
+
+    bootstrapped = true;
+  }
+
+  function createRestartRequest({
+    requestedAt = Date.now(),
+    detectedAt = null,
+    cause = DEFAULT_RESTART_CAUSE,
+    source = 'unknown',
+    status = 'requested',
+    details = {},
+  } = {}) {
+    bootstrapRestartLogTable();
+    const db = getDatabase();
+    const result = db.prepare(`
+      INSERT INTO ${RESTART_LOG_TABLE} (requested_at, detected_at, event_type, restart_cause, source, status, details_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      Math.floor(Number(requestedAt) || Date.now()),
+      detectedAt == null ? null : Math.floor(Number(detectedAt) || Date.now()),
+      DEFAULT_EVENT_TYPE,
+      normalizeRestartCause(cause),
+      String(source || 'unknown'),
+      String(status || 'requested'),
+      JSON.stringify(details || {}),
+    );
+    return Number(result.lastInsertRowid);
+  }
+
+  function createLifecycleEvent({
+    eventAt = Date.now(),
+    eventType,
+    cause = DEFAULT_RESTART_CAUSE,
+    source = 'unknown',
+    status = 'completed',
+    details = {},
+  } = {}) {
+    bootstrapRestartLogTable();
+    const db = getDatabase();
+    const timestamp = Math.floor(Number(eventAt) || Date.now());
+    const result = db.prepare(`
+      INSERT INTO ${RESTART_LOG_TABLE} (requested_at, detected_at, event_type, restart_cause, source, status, details_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      timestamp,
+      timestamp,
+      normalizeEventType(eventType),
+      normalizeRestartCause(cause),
+      String(source || 'unknown'),
+      String(status || 'completed'),
+      JSON.stringify(details || {}),
+    );
+    return Number(result.lastInsertRowid);
+  }
+
+  function updateRestartStatus(id, {
+    detectedAt,
+    status,
+    details,
+  } = {}) {
+    bootstrapRestartLogTable();
+    if (!Number.isFinite(Number(id))) {
+      return false;
+    }
+
+    const db = getDatabase();
+    const current = normalizeRecord(db.prepare(`
+      SELECT *
+      FROM ${RESTART_LOG_TABLE}
+      WHERE id = ?
+      LIMIT 1
+    `).get(Number(id)));
+
+    if (!current) {
+      return false;
+    }
+
+    const nextDetails = details === undefined
+      ? current.details
+      : {...current.details, ...(details || {})};
+
+    db.prepare(`
+      UPDATE ${RESTART_LOG_TABLE}
+      SET detected_at = ?,
+          status = ?,
+          details_json = ?
+      WHERE id = ?
+    `).run(
+      detectedAt == null ? current.detectedAt : Math.floor(Number(detectedAt)),
+      String(status || current.status),
+      JSON.stringify(nextDetails || {}),
+      Number(id),
+    );
+
+    return true;
+  }
+
+  function listRecentRestartRecords(limit = 20) {
+    bootstrapRestartLogTable();
+    const db = getDatabase();
+    return db.prepare(`
+      SELECT *
+      FROM ${RESTART_LOG_TABLE}
+      ORDER BY requested_at DESC, id DESC
+      LIMIT ?
+    `).all(Math.max(1, Number(limit) || 20)).map(normalizeRecord);
+  }
+
+  function getLastLifecycleEvent() {
+    bootstrapRestartLogTable();
+    const db = getDatabase();
+    return normalizeRecord(db.prepare(`
+      SELECT *
+      FROM ${RESTART_LOG_TABLE}
+      ORDER BY requested_at DESC, id DESC
+      LIMIT 1
+    `).get());
+  }
+
+  return {
+    createRestartRequest,
+    createLifecycleEvent,
+    updateRestartStatus,
+    getLastLifecycleEvent,
+    listRecentRestartRecords,
+  };
+}

package/server/services/persistence/index.js

@@ -0,0 +1,19 @@
+import {createConfigDao} from './createConfigDao.js';
+import {createEntryTokenDao} from './createEntryTokenDao.js';
+import {createDatabaseProvider} from './createDatabaseProvider.js';
+import {createRestartLogDao} from './createRestartLogDao.js';
+
+export function createPersistence(services) {
+    const getDatabase = createDatabaseProvider({
+        getDatabasePath: () => services.getSystemConfig().persistence.dbPath,
+    });
+
+    return {
+        getDatabase,
+        configDao: createConfigDao({
+            getDatabase,
+        }),
+        entryTokenDao: createEntryTokenDao({getDatabase}),
+        restartLogDao: createRestartLogDao({getDatabase}),
+    };
+}

package/server/services/pubsub/createEventStore.js

@@ -0,0 +1,54 @@
+function normalizeServiceName(service) {
+  const value = String(service || '').trim();
+  return value || 'unknown';
+}
+
+function cloneEvent(event) {
+  return {
+    sequence: event.sequence,
+    service: event.service,
+    type: event.type,
+    at: event.at,
+    payload: event.payload,
+    snapshot: event.snapshot,
+  };
+}
+
+export function createEventStore(services) {
+  const latestByService = new Map();
+  const history = [];
+  const bus = services.getPubSub();
+
+  bus.subscribe((event) => {
+    if (event.snapshot) {
+      latestByService.set(event.service, cloneEvent(event));
+    }
+
+    history.push(cloneEvent(event));
+    if (history.length > 500) {
+      history.splice(0, history.length - 500);
+    }
+  });
+
+  function getLatestSnapshot() {
+    return Array.from(latestByService.values(), (event) => cloneEvent(event));
+  }
+
+  function getHistory(limit = 100) {
+    const safeLimit = Math.max(0, Math.floor(Number(limit) || 0));
+    const source = safeLimit > 0 ? history.slice(-safeLimit) : history;
+    return source.map((event) => cloneEvent(event));
+  }
+
+  function getLatestEvent(service) {
+    const event = latestByService.get(normalizeServiceName(service));
+    return event ? cloneEvent(event) : null;
+  }
+
+  return {
+    getLatestSnapshot,
+    getHistory,
+    getLatestEvent,
+    getServiceState: getLatestEvent,
+  };
+}

package/server/services/pubsub/createPubSub.js

@@ -0,0 +1,89 @@
+import {createExactMatchPredicate} from '../../../utils/predicates.js';
+
+function normalizeServiceName(service) {
+  const value = String(service || '').trim();
+  return value || 'unknown';
+}
+
+function cloneEvent(event) {
+  return {
+    sequence: event.sequence,
+    service: event.service,
+    type: event.type,
+    at: event.at,
+    payload: event.payload,
+    snapshot: event.snapshot,
+  };
+}
+
+function createListenerEntry(listener, predicateOrObject) {
+  if (typeof listener !== 'function') {
+    return null;
+  }
+
+  let predicate = null;
+  if (typeof predicateOrObject === 'function') {
+    predicate = predicateOrObject;
+  } else if (predicateOrObject && typeof predicateOrObject === 'object') {
+    const normalizedFilters = {...predicateOrObject};
+    if (normalizedFilters.service !== undefined) {
+      normalizedFilters.service = normalizeServiceName(normalizedFilters.service);
+    }
+    predicate = Object.keys(normalizedFilters).length
+      ? createExactMatchPredicate(normalizedFilters)
+      : null;
+  }
+
+  return {
+    notify(event) {
+      if (predicate && !predicate(event)) {
+        return;
+      }
+
+      listener(event);
+    },
+  };
+}
+
+export function createPubSub() {
+  const listeners = new Set();
+  let nextSequence = 1;
+
+  function publish(service, payload, options = {}) {
+    const event = {
+      sequence: nextSequence++,
+      service: normalizeServiceName(service),
+      type: String(options.type || 'event').trim() || 'event',
+      at: new Date().toISOString(),
+      payload,
+      snapshot: options.snapshot !== false,
+    };
+
+    for (const listener of listeners) {
+      try {
+        listener.notify(cloneEvent(event));
+      } catch (_error) {
+        // Best effort: keep the bus alive even if one subscriber fails.
+      }
+    }
+
+    return cloneEvent(event);
+  }
+
+  function subscribe(listener, predicateOrObject) {
+    const entry = createListenerEntry(listener, predicateOrObject);
+    if (!entry) {
+      return () => {};
+    }
+
+    listeners.add(entry);
+    return () => {
+      listeners.delete(entry);
+    };
+  }
+
+  return {
+    publish,
+    subscribe,
+  };
+}

package/server/services/pubsub/createServiceEvents.js

@@ -0,0 +1,29 @@
+import {PUBSUB_EVENT_STATE_CHANGED} from './serviceEventConstants.js';
+
+export function createServiceEvents(services) {
+  function publish(service, payload, options = {}) {
+    return services.getPubSub().publish(service, payload, options);
+  }
+
+  function publishState(service, state, options = {}) {
+    return publish(service, state, {
+      type: String(options.type || PUBSUB_EVENT_STATE_CHANGED).trim() || PUBSUB_EVENT_STATE_CHANGED,
+      ...options,
+      snapshot: options.snapshot ?? true,
+    });
+  }
+
+  function publishEvent(service, type, payload, options = {}) {
+    return publish(service, payload, {
+      ...options,
+      type: String(type || 'event').trim() || 'event',
+      snapshot: options.snapshot ?? false,
+    });
+  }
+
+  return {
+    publish,
+    publishState,
+    publishEvent,
+  };
+}

package/server/services/pubsub/serviceEventConstants.js

@@ -0,0 +1,39 @@
+export const PUBSUB_SERVICE_SOCKET = 'socket';
+export const PUBSUB_SERVICE_SESSION = 'session';
+export const PUBSUB_SERVICE_TASK_MANAGER = 'task-manager';
+export const PUBSUB_SERVICE_TOKEN_MANAGER = 'token-manager';
+export const PUBSUB_SERVICE_UPDATE_MANAGER = 'update-manager';
+export const PUBSUB_SERVICE_CONFIG = 'config';
+export const PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK = 'admin:force-update-check';
+export const PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE = 'admin:install-update';
+export const PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER = 'admin:open-qr-browser';
+export const PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER = 'admin:open-server-info-browser';
+export const PUBSUB_SERVICE_ADMIN_RESTART_SERVICE = 'admin:restart-service';
+export const PUBSUB_SERVICE_ADMIN_TOGGLE_QR_OVERLAY = 'admin:toggle-qr-overlay';
+export const PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN = 'admin:rotate-entry-token';
+
+export const PUBSUB_EVENT_STATE_CHANGED = 'state.changed';
+
+export const PUBSUB_EVENT_SOCKET_CLIENT_CONNECTED = 'client.connected';
+export const PUBSUB_EVENT_SOCKET_CLIENT_DISCONNECTED = 'client.disconnected';
+export const PUBSUB_EVENT_SESSION_CREATED = 'session.created';
+
+export const PUBSUB_EVENT_UPDATE_CHECK = 'update.check';
+export const PUBSUB_EVENT_UPDATE_AVAILABLE = 'update.available';
+export const PUBSUB_EVENT_UPDATE_ERROR = 'update.error';
+export const PUBSUB_EVENT_TOKEN_CHANGED = 'token.changed';
+export const PUBSUB_EVENT_CONFIG_UPDATED = 'config.updated';
+export const PUBSUB_EVENT_CONFIG_DELETED = 'config.deleted';
+
+export const PUBSUB_EVENT_ADMIN_COMPLETED = 'completed';
+export const PUBSUB_EVENT_ADMIN_STARTED = 'started';
+export const PUBSUB_EVENT_ADMIN_FAILED = 'failed';
+export const PUBSUB_EVENT_ADMIN_REJECTED_NO_COMMAND = 'rejected.no-command';
+export const PUBSUB_EVENT_ADMIN_REJECTED_DISABLED = 'rejected.disabled';
+export const PUBSUB_EVENT_ADMIN_UNCHANGED = 'unchanged';
+export const PUBSUB_EVENT_ADMIN_ROTATED = 'rotated';
+export const PUBSUB_EVENT_ADMIN_TOGGLED = 'toggled';
+export const PUBSUB_EVENT_ADMIN_CLIENT_OPENED = 'client.opened';
+export const PUBSUB_EVENT_ADMIN_SERVER_OPEN_FAILED = 'server.open.failed';
+export const PUBSUB_EVENT_ADMIN_SERVER_OPENED = 'server.opened';
+export const PUBSUB_EVENT_ADMIN_RESTART_DETECTED = 'restart.detected';

package/server/services/remotes/createRemotes.js

@@ -0,0 +1,25 @@
+import {createBrowser} from "../../remotes/browser/index.js";
+import {createSamsungRemote} from "../../remotes/samsung/createSamsungRemote.js";
+import {createPreviewStreamer} from "../../remotes/preview/createPreviewStreamer.js";
+import {createAdminActions} from "../../remotes/admin/index.js";
+import {createVlc} from "../../remotes/vlc/index.js";
+import {createWindowActions} from "../../remotes/window/index.js";
+
+export function createRemotes(services) {
+    const osService = services.getOs();
+    const browser = createBrowser(osService);
+    const samsung = createSamsungRemote(services);
+    const preview = createPreviewStreamer(services);
+    const adminActions = createAdminActions(services);
+    const vlc = createVlc(services);
+    const windowActions = createWindowActions(osService);
+
+    return {
+        browser,
+        samsung,
+        preview,
+        adminActions,
+        vlc,
+        windowActions,
+    };
+}

package/server/services/server/createHttpsServer.js

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+import https from "node:https";
+
+export function createHttpsServer(app, config) {
+    if (!config.https.sslKeyPath || !config.https.sslCertPath) {
+        throw new Error('HTTPS=true exige SSL_KEY_PATH et SSL_CERT_PATH.');
+    }
+
+    const key = fs.readFileSync(config.https.sslKeyPath, 'utf8');
+    const cert = fs.readFileSync(config.https.sslCertPath, 'utf8');
+    return https.createServer({key, cert}, app);
+}

package/server/services/server/createServer.js

@@ -0,0 +1,66 @@
+import http from 'node:http';
+import express from 'express';
+import {Server} from 'socket.io';
+import {getPublicUrl} from '../../utils/network.js';
+import cookieParser from "cookie-parser";
+import {createHttpsServer} from "./createHttpsServer.js";
+import {createLogger} from '../../application/logger.js';
+
+export function createServer(services) {
+    const log = createLogger('server:create');
+    const {
+        getSystemConfig
+    } = services;
+
+    const config = getSystemConfig();
+    const serverStartedAt = Date.now();
+    const app = express();
+    const cookies = cookieParser(config.session.cookieSecret);
+
+    const server = config.https.enabled
+        ? createHttpsServer(app, config)
+        : http.createServer(app);
+    const sockets = new Set();
+
+    const io = new Server(server, {});
+    log.debug({
+        protocol: config.protocol,
+        port: config.port,
+        httpsEnabled: Boolean(config.https.enabled),
+    }, 'Serveur HTTP initialise');
+
+    server.on('connection', (socket) => {
+        sockets.add(socket);
+        log.trace({socketCount: sockets.size}, 'Connexion HTTP ouverte');
+        socket.on('close', () => {
+            sockets.delete(socket);
+            log.trace({socketCount: sockets.size}, 'Connexion HTTP fermee');
+        });
+    });
+
+    const basePublicUrl = getPublicUrl(
+        config.port,
+        config.protocol,
+        config.serverHost);
+
+    return {
+        server,
+        io,
+        app,
+        basePublicUrl,
+        serverStartedAt,
+        cookieParser: cookies,
+        closeIdleConnections: () => {
+            log.debug('Fermeture connexions HTTP inactives');
+            server.closeIdleConnections?.();
+        },
+        destroyConnections: () => {
+            log.debug({socketCount: sockets.size}, 'Destruction connexions HTTP restantes');
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+            sockets.clear();
+        }
+    };
+}
+    

package/server/services/sse/createSseService.js

@@ -0,0 +1,96 @@
+import {
+  createExactMatchPredicate,
+  formatSseMessage
+} from "./utils.js";
+
+export function createSseService() {
+  const subscriptions = new Map();
+  let nextId = 1;
+
+  function createSubscription({filters} = {}) {
+    const id = `sub-${nextId++}`;
+    subscriptions.set(id, {
+      id,
+      predicate: createExactMatchPredicate(filters || {}),
+      pendingEvents: [],
+      response: null,
+    });
+    return id;
+  }
+
+  function emit(event) {
+    for (const subscription of subscriptions.values()) {
+      if (!subscription.predicate(event)) {
+        continue;
+      }
+
+      if (subscription.response) {
+        subscription.response.write(formatSseMessage(event));
+        continue;
+      }
+
+      subscription.pendingEvents.push(event);
+      if (subscription.pendingEvents.length > 50) {
+        subscription.pendingEvents.shift();
+      }
+    }
+  }
+
+  function connect(id, req, res) {
+    const subscription = subscriptions.get(id);
+    if (!subscription) {
+      return false;
+    }
+
+    if (subscription.response && subscription.response !== res) {
+      subscription.response.end();
+    }
+
+    subscription.response = res;
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+    res.write('retry: 3000\n\n');
+
+    for (const event of subscription.pendingEvents) {
+      res.write(formatSseMessage(event));
+    }
+    subscription.pendingEvents = [];
+
+    req.on('close', () => {
+      if (subscription.response === res) {
+        subscription.response = null;
+      }
+      res.end();
+    });
+
+    return true;
+  }
+
+  function deleteSubscription(id) {
+    const subscription = subscriptions.get(id);
+    if (!subscription) {
+      return false;
+    }
+
+    subscription.response?.end();
+    subscriptions.delete(id);
+    return true;
+  }
+
+  function closeAll() {
+    for (const [id, subscription] of subscriptions.entries()) {
+      subscription.response?.end();
+      subscriptions.delete(id);
+    }
+  }
+
+  return {
+    createSubscription,
+    connect,
+    deleteSubscription,
+    emit,
+    closeAll,
+  };
+}

package/server/services/sse/utils.js

@@ -0,0 +1,7 @@
+export {createExactMatchPredicate} from '../../../utils/predicates.js';
+
+export function formatSseMessage(event = {}) {
+    const eventName = String(event.name || event.type || 'message').trim() || 'message';
+    const payload = event.payload === undefined ? {} : event.payload;
+    return `event: ${eventName}\ndata: ${JSON.stringify(payload)}\n\n`;
+}