@velor/remote-mouse 6.4.8

package/server/application/start.js

@@ -0,0 +1,95 @@
+import qrcodeTerminal from 'qrcode-terminal';
+import {bootstrapApi} from '../init/bootstrapApi.js';
+import {logStartupConfig} from '../services/config/logConfig.js';
+import {bootstrapSocket} from '../init/bootstrapSocket.js';
+import {startCliServer} from '../term/srv/startCliServer.js';
+import {startConfigObserver} from '../init/observers/startConfigObserver.js';
+import {startNotificationObserver} from '../init/observers/startNotificationObserver.js';
+import {startDisplaySizeObserver} from '../init/observers/startDisplaySizeObserver.js';
+import {startQrOverlayRefreshObserver} from '../init/observers/startQrOverlayRefreshObserver.js';
+import {startQrOverlayHoverObserver} from '../init/observers/startQrOverlayHoverObserver.js';
+import {notifyIfRestarted} from '../remotes/admin/notifyIfRestarted.js';
+import {ensureApplicationLifecycleState} from './state.js';
+import {createLogger} from './logger.js';
+
+export function createApplicationStart(services) {
+  function logStartupUrls(urls) {
+    const entries = [
+      ['Entry', urls.entryUrl],
+      ['QR', urls.qrUrl],
+      ['Admin config', urls.adminConfigUrl],
+      ['Server info', urls.serverInfoUrl],
+      ['Health', urls.healthUrl]
+    ].filter(([, value]) => Boolean(value));
+
+    console.log('URLs:');
+    for (const [label, value] of entries) {
+      console.log(`  ${label}: ${value}`);
+    }
+  }
+
+  return async function start() {
+    const log = createLogger('server');
+    const state = ensureApplicationLifecycleState(services);
+    const config = services.getConfig();
+    const systemConfig = services.getSystemConfig();
+
+    const httpServer = services.getServer().server;
+    const qrOverlay = services.getQrOverlay();
+    const taskManager = services.getTaskManager();
+    const tokenManager = services.getTokenManager();
+
+    state.stopConfigObserver = startConfigObserver(services);
+    state.stopNotificationObserver = startNotificationObserver(services);
+    state.stopDisplaySizeObserver = startDisplaySizeObserver(services);
+    state.stopQrOverlayRefreshObserver = startQrOverlayRefreshObserver(services);
+    state.stopQrOverlayHoverObserver = startQrOverlayHoverObserver(services);
+    notifyIfRestarted(services);
+
+    tokenManager.createToken();
+
+    bootstrapApi(services);
+    bootstrapSocket(services);
+
+    process.once('SIGINT', () => {
+      void state.shutdown?.('SIGINT');
+    });
+    process.once('SIGTERM', () => {
+      void state.shutdown?.('SIGTERM');
+    });
+
+    await new Promise((resolve) => {
+      httpServer.listen(systemConfig.port, async () => {
+        const urls = services.getUrls();
+
+        logStartupConfig(log, {
+          systemConfig,
+          config,
+        });
+
+        log.info({url: urls.entryUrl, qrUrl: urls.qrUrl}, 'Remote Mouse server démarré');
+        logStartupUrls(urls);
+        log.info('Scanner ce QR avec le mobile');
+
+        if (services.getConfig().qrOverlay?.enabled) {
+          await qrOverlay.show();
+        }
+
+        await taskManager.start();
+
+        try {
+          state.cliServer = await startCliServer(services);
+        } catch (error) {
+          log.error({err: error}, 'Erreur au démarrage de l interface CLI locale');
+        }
+
+        qrcodeTerminal.generate(urls.entryUrl, {small: true});
+        resolve();
+      });
+    });
+
+    return {
+      shutdown: state.shutdown,
+    };
+  };
+}

package/server/application/state.js

@@ -0,0 +1,19 @@
+const lifecycleState = new WeakMap();
+
+export function ensureApplicationLifecycleState(services) {
+  let state = lifecycleState.get(services);
+  if (!state) {
+    state = {
+      cliServer: null,
+      shuttingDown: false,
+      stopConfigObserver: () => {},
+      stopNotificationObserver: () => {},
+      stopDisplaySizeObserver: () => {},
+      stopQrOverlayRefreshObserver: () => {},
+      stopQrOverlayHoverObserver: () => {},
+      shutdown: null,
+    };
+    lifecycleState.set(services, state);
+  }
+  return state;
+}

package/server/connection/api/admin-actions.router.js

@@ -0,0 +1,65 @@
+import express from 'express';
+import path from 'node:path';
+
+import {
+    discoverSamsungDevices,
+    getSamsungDeviceMac,
+    normalizeMac,
+    pickSamsungDevice
+} from '../../remotes/samsung/device-config.js';
+
+export {
+    buildManagedConfigPayload,
+    coerceConfigValue,
+} from './configs.js';
+
+export function createAdminConfigActionsRouter(services) {
+    const router = express.Router();
+
+    router.post('/configs/samsung/discover', async (_req, res) => {
+        try {
+            const discoverDevices = discoverSamsungDevices({
+                getConfig: () => services.getConfig().samsungTv,
+            });
+            const samsungConfig = services.getConfig().samsungTv;
+            const devices = await discoverDevices();
+            const selected = pickSamsungDevice(
+                devices,
+                samsungConfig.alwaysAutoResolve
+                    ? {...samsungConfig, host: '', mac: ''}
+                    : samsungConfig,
+            );
+
+            res.json({
+                ok: true,
+                devices: devices.map((device) => ({
+                    name: String(device?.name || '').trim(),
+                    model: String(device?.model || '').trim(),
+                    host: String(device?.ip || '').trim(),
+                    mac: getSamsungDeviceMac(device),
+                    isSelected: Boolean(
+                        selected
+                        && String(selected.ip || '').trim() === String(device?.ip || '').trim()
+                        && normalizeMac(getSamsungDeviceMac(selected)) === normalizeMac(getSamsungDeviceMac(device)),
+                    ),
+                })),
+            });
+        } catch (error) {
+            res.status(500).json({
+                ok: false,
+                message: String(error?.message || error || 'Erreur de decouverte Samsung.'),
+            });
+        }
+    });
+
+    router.post('/restart-service', async (_req, res) => {
+        const result = await services.getApplicationDaemonService().restart({
+            cause: 'user',
+            source: 'admin-http',
+        });
+
+        res.status(result?.ok ? 200 : 500).json(result);
+    });
+
+    return router;
+}

package/server/connection/api/admin-configs.router.js

@@ -0,0 +1,165 @@
+import express from 'express';
+
+import {CONFIG_PATHS} from '../../services/config/configPaths.js';
+import {
+  adminConfigDefaults,
+  adminConfigSchema,
+  buildConfigEntry,
+  coerceConfigValue,
+  getFieldDefinition,
+  getManagedConfigSnapshot,
+} from './configs.js';
+
+export function createAdminConfigsRouter(services) {
+  const getConfig = services.getConfig;
+  const getSystemConfig = services.getSystemConfig;
+  const router = express.Router();
+
+  async function getManagedContext() {
+    const vlcAvailable = await services.getRemotes().vlc.isAvailable();
+    const managedPaths = CONFIG_PATHS;
+    const schema = adminConfigSchema;
+    const defaults = getManagedConfigSnapshot({
+      ...adminConfigDefaults,
+      vlc: {
+        enabled: false,
+      },
+    }, managedPaths);
+    const config = getManagedConfigSnapshot({
+      ...getConfig(),
+      vlc: {
+        enabled: vlcAvailable ? getConfig()?.vlc?.enabled : false,
+      },
+    }, managedPaths);
+
+    return {
+      managedPaths,
+      schema,
+      defaults,
+      config,
+    };
+  }
+
+  router.get('/', async (_req, res) => {
+    const {
+      managedPaths,
+      schema,
+      defaults,
+      config,
+    } = await getManagedContext();
+
+    res.json({
+      configs: managedPaths.map((pathKey) => buildConfigEntry(pathKey, schema, config, defaults)),
+      defaults,
+      schema,
+      managedPaths,
+      systemConfig: {
+        adminActionsEnabled: Boolean(getSystemConfig().adminActionsEnabled),
+      },
+    });
+  });
+
+  router.get('/:configId', async (req, res) => {
+    const pathKey = String(req.params.configId || '').trim();
+    const {
+      managedPaths,
+      schema,
+      defaults,
+      config,
+    } = await getManagedContext();
+
+    if (!managedPaths.includes(pathKey)) {
+      res.status(404).json({
+        ok: false,
+        message: 'Invalid config path.',
+      });
+      return;
+    }
+
+    res.json({
+      config: buildConfigEntry(pathKey, schema, config, defaults),
+    });
+  });
+
+  router.patch('/:configId', express.json(), async (req, res) => {
+    const pathKey = String(req.params.configId || '').trim();
+    const {
+      managedPaths,
+      schema,
+      defaults,
+    } = await getManagedContext();
+
+    if (!managedPaths.includes(pathKey)) {
+      res.status(404).json({
+        ok: false,
+        message: 'Invalid config path.',
+      });
+      return;
+    }
+
+    const field = getFieldDefinition(schema, pathKey);
+    if (!field) {
+      res.status(404).json({
+        ok: false,
+        message: 'Unknown config field.',
+      });
+      return;
+    }
+
+    if (!req.body || !Object.hasOwn(req.body, 'value')) {
+      res.status(400).json({
+        ok: false,
+        message: 'Invalid payload: value expected.',
+      });
+      return;
+    }
+
+    try {
+      if (req.body.value === null) {
+        services.getConfigService().resetConfig(pathKey);
+      } else {
+        const nextValue = coerceConfigValue(req.body.value, field);
+        services.getConfigService().setConfig(pathKey, nextValue);
+      }
+
+      const nextContext = await getManagedContext();
+      res.json({
+        ok: true,
+        message: 'Configuration updated.',
+        config: buildConfigEntry(pathKey, nextContext.schema, nextContext.config, nextContext.defaults),
+      });
+    } catch (error) {
+      res.status(400).json({
+        ok: false,
+        message: `Configuration invalide: ${error.message}`,
+      });
+    }
+  });
+
+  router.delete('/:configId', async (req, res) => {
+    const pathKey = String(req.params.configId || '').trim();
+    const {
+      managedPaths,
+      schema,
+      defaults,
+    } = await getManagedContext();
+
+    if (!managedPaths.includes(pathKey)) {
+      res.status(404).json({
+        ok: false,
+        message: 'Invalid config path.',
+      });
+      return;
+    }
+
+    services.getConfigService().resetConfig(pathKey);
+    const nextContext = await getManagedContext();
+    res.json({
+      ok: true,
+      message: `${pathKey} reset to default.`,
+      config: buildConfigEntry(pathKey, schema, nextContext.config, defaults),
+    });
+  });
+
+  return router;
+}

package/server/connection/api/admin-remotes.router.js

@@ -0,0 +1,61 @@
+import express from 'express';
+
+export function createAdminRemotesRouter(services) {
+  const router = express.Router();
+
+  function isBrowserEnabled(config, browserId) {
+    return config?.browser?.enabled !== false && config?.browser?.[browserId] !== false;
+  }
+
+  router.get('/browsers', async (_req, res) => {
+    const config = services.getConfig();
+    const browsers = await services.getSystem().listBrowsers();
+    res.json({
+      browsers: browsers.map((browser) => ({
+        ...browser,
+        enabled: isBrowserEnabled(config, browser.id),
+      })),
+    });
+  });
+
+  router.get('/', async (_req, res) => {
+    const config = services.getConfig();
+    const vlcAvailable = await services.getSystem().isVlcAvailable();
+    const remotes = [
+      {
+        id: 'browser',
+        labelKey: 'preferences.remote.browser',
+        enabled: config?.browser?.enabled !== false,
+      },
+      {
+        id: 'keyboard',
+        labelKey: 'preferences.remote.keyboard',
+        enabled: config?.keyboard?.enabled !== false,
+      },
+      {
+        id: 'preview',
+        labelKey: 'preferences.remote.preview',
+        enabled: config?.preview?.enabled !== false,
+      },
+      {
+        id: 'samsung',
+        labelKey: 'preferences.remote.samsung',
+        enabled: Boolean(config?.samsungTv?.enabled),
+      },
+    ];
+
+    if (vlcAvailable) {
+      remotes.splice(2, 0, {
+        id: 'vlc',
+        labelKey: 'preferences.remote.vlc',
+        enabled: config?.vlc?.enabled !== false,
+      });
+    }
+
+    res.json({
+      remotes,
+    });
+  });
+
+  return router;
+}

package/server/connection/api/admin-subs.router.js

@@ -0,0 +1,49 @@
+import express from 'express';
+import {PUBSUB_SERVICE_CONFIG} from '../../services/pubsub/serviceEventConstants.js';
+
+export function createAdminSubsRouter(services) {
+  const router = express.Router();
+
+  router.post('/configs', express.json(), (_req, res) => {
+    const id = services.getSseService().createSubscription({
+      filters: {
+        service: PUBSUB_SERVICE_CONFIG,
+      },
+    });
+
+    res.json({
+      ok: true,
+      id,
+      eventsUrl: `/api/admin/subs/${id}`,
+    });
+  });
+
+  router.get('/:id', (req, res) => {
+    const connected = services.getSseService().connect(String(req.params.id || '').trim(), req, res);
+    if (connected) {
+      return;
+    }
+
+    res.status(404).json({
+      ok: false,
+      message: 'Subscription not found.',
+    });
+  });
+
+  router.delete('/:id', (req, res) => {
+    const removed = services.getSseService().deleteSubscription(String(req.params.id || '').trim());
+    if (!removed) {
+      res.status(404).json({
+        ok: false,
+        message: 'Subscription not found.',
+      });
+      return;
+    }
+
+    res.json({
+      ok: true,
+    });
+  });
+
+  return router;
+}

package/server/connection/api/client.router.js

@@ -0,0 +1,15 @@
+import express from 'express';
+
+export function createStaticShareRouter({
+                                    publicDir,
+                                    clientDir,
+                                    sharedUtilsDir,
+                                }) {
+    const router = express.Router();
+
+    router.use(express.static(publicDir));
+    router.use('/client', express.static(clientDir));
+    router.use('/utils', express.static(sharedUtilsDir));
+    return router;
+}
+

package/server/connection/api/configs.js

@@ -0,0 +1,96 @@
+import {CONFIG_PATHS} from '../../services/config/configPaths.js';
+import {getConfigFieldDefinition, getManagedConfigSchema} from '../../services/config/configSchema.js';
+import {DEFAULT_PERSISTED_CONFIG} from '../../services/config/defaultConfig.js';
+import {setNestedValue} from '../../../utils/object.utils.js';
+
+export const adminConfigSchema = getManagedConfigSchema(CONFIG_PATHS);
+
+export function getValueAtPath(source, dottedPath) {
+  return String(dottedPath || '')
+    .split('.')
+    .filter(Boolean)
+    .reduce((cursor, segment) => (cursor == null ? undefined : cursor[segment]), source);
+}
+
+export function coerceConfigValue(rawValue, field) {
+  if (!field) {
+    return rawValue;
+  }
+
+  if (field.type === 'boolean') {
+    if (typeof rawValue === 'string') {
+      const normalized = rawValue.trim().toLowerCase();
+      if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
+        return true;
+      }
+      if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+        return false;
+      }
+      throw new Error('must be a boolean');
+    }
+    return Boolean(rawValue);
+  }
+
+  if (field.type === 'integer') {
+    const parsed = Number.parseInt(String(rawValue), 10);
+    if (!Number.isFinite(parsed)) {
+      throw new Error('must be an integer');
+    }
+    return parsed;
+  }
+
+  if (field.type === 'number') {
+    const parsed = Number.parseFloat(String(rawValue));
+    if (!Number.isFinite(parsed)) {
+      throw new Error('must be a number');
+    }
+    return parsed;
+  }
+
+  const value = String(rawValue ?? '').trim();
+  if (Array.isArray(field.options) && field.options.length > 0 && !field.options.includes(value)) {
+    throw new Error(`must be one of: ${field.options.join(', ')}`);
+  }
+
+  return value;
+}
+
+export function buildManagedConfigPayload(rawValues, schema = adminConfigSchema) {
+  const payload = {};
+
+  for (const [pathKey, rawValue] of Object.entries(rawValues || {})) {
+    const field = getFieldDefinition(schema, pathKey);
+    if (!field) {
+      continue;
+    }
+    const coercedValue = coerceConfigValue(rawValue, field);
+    setNestedValue(payload, pathKey, coercedValue);
+  }
+
+  return payload;
+}
+
+export function getManagedConfigSnapshot(config, managedPaths = CONFIG_PATHS) {
+  const snapshot = {};
+
+  for (const pathKey of managedPaths) {
+    setNestedValue(snapshot, pathKey, getValueAtPath(config, pathKey));
+  }
+  return snapshot;
+}
+
+export function getFieldDefinition(schema, pathKey) {
+  const [sectionKey, fieldKey] = String(pathKey || '').split('.');
+  return schema?.[sectionKey]?.fields?.[fieldKey] || getConfigFieldDefinition(pathKey);
+}
+
+export function buildConfigEntry(pathKey, schema, config, defaults) {
+  return {
+    id: pathKey,
+    field: getFieldDefinition(schema, pathKey),
+    value: getValueAtPath(config, pathKey),
+    defaultValue: getValueAtPath(defaults, pathKey),
+  };
+}
+
+export const adminConfigDefaults = getManagedConfigSnapshot(DEFAULT_PERSISTED_CONFIG, CONFIG_PATHS);

package/server/connection/api/qr-page.handler.js

@@ -0,0 +1,17 @@
+import QRCode from "qrcode";
+import {renderQrPage} from "../../services/overlay/renderQrPage.js";
+
+export function createQrPageHandler(services) {
+    return async (_req, res) => {
+        try {
+            const publicUrl = String(services.getUrls().entryUrl || '');
+            const qrDataUrl = await QRCode.toDataURL(publicUrl);
+            res.type('html').send(renderQrPage({
+                qrDataUrl,
+                publicUrl,
+            }));
+        } catch (_error) {
+            res.status(500).type('text/plain').send('QR generation failed');
+        }
+    }
+}

package/server/connection/api/remotes.router.js

@@ -0,0 +1,30 @@
+import express from 'express';
+
+export function createRemotesRouter(services) {
+  const router = express.Router();
+
+  router.get('/:remoteId/status', async (req, res) => {
+    const remoteId = String(req.params.remoteId || '').trim();
+
+    if (remoteId === 'samsung') {
+      const enabled = Boolean(services.getConfig()?.samsungTv?.enabled);
+      const power = enabled
+        ? await services.getRemotes().samsung.getPowerState({ maxAgeMs: 2500 })
+        : 'disabled';
+
+      res.json({
+        remoteId,
+        enabled,
+        power,
+      });
+      return;
+    }
+
+    res.status(404).json({
+      ok: false,
+      message: 'Unknown remote.',
+    });
+  });
+
+  return router;
+}