@velor/remote-mouse 6.4.8

package/server/term/srv/commands/configCommand.js

@@ -0,0 +1,84 @@
+import {CONFIG_PATHS} from '../../../services/config/configPaths.js';
+import {
+  adminConfigSchema,
+  coerceConfigValue,
+  getFieldDefinition,
+} from '../../../connection/api/configs.js';
+
+export async function executeConfigCommand(services, args = {}) {
+  if (!args.action) {
+    return {
+      ok: true,
+      message: 'Configuration persistée effective.',
+      data: services.getConfig(),
+    };
+  }
+
+  if (args.action === 'get') {
+    const pathKey = String(args.path || '').trim();
+    if (!CONFIG_PATHS.includes(pathKey)) {
+      return {
+        ok: false,
+        message: `Chemin de configuration invalide: ${pathKey || '(vide)'}`,
+      };
+    }
+
+    return {
+      ok: true,
+      message: `Configuration ${pathKey}.`,
+      data: {
+        path: pathKey,
+        value: services.getConfigService().getConfig(pathKey),
+      },
+    };
+  }
+
+  if (args.action === 'set') {
+    const pathKey = String(args.path || '').trim();
+    if (!CONFIG_PATHS.includes(pathKey)) {
+      return {
+        ok: false,
+        message: `Chemin de configuration invalide: ${pathKey || '(vide)'}`,
+      };
+    }
+
+    if (args.value === '') {
+      return {
+        ok: false,
+        message: 'Valeur de configuration manquante.',
+      };
+    }
+
+    const field = getFieldDefinition(adminConfigSchema, pathKey);
+    if (!field) {
+      return {
+        ok: false,
+        message: `Champ de configuration inconnu: ${pathKey}`,
+      };
+    }
+
+    try {
+      const nextValue = coerceConfigValue(String(args.value || ''), field);
+      services.getConfigService().setConfig(pathKey, nextValue);
+
+      return {
+        ok: true,
+        message: `Configuration ${pathKey} mise a jour.`,
+        data: {
+          path: pathKey,
+          value: services.getConfigService().getConfig(pathKey),
+        },
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        message: `Configuration invalide: ${error.message}`,
+      };
+    }
+  }
+
+  return {
+    ok: false,
+    message: `Action config inconnue: ${args.action}`,
+  };
+}

package/server/term/srv/commands/helpCommand.js

@@ -0,0 +1,6 @@
+export async function executeHelpCommand() {
+  return {
+    ok: true,
+    message: 'Utilisez remote-mouse --help pour afficher les commandes disponibles.',
+  };
+}

package/server/term/srv/commands/infoCommand.js

@@ -0,0 +1,7 @@
+export async function executeInfoCommand(services) {
+  return {
+    ok: true,
+    message: 'Capacites du serveur.',
+    data: await services.getSystem().getInfo(),
+  };
+}

package/server/term/srv/commands/openQrCommand.js

@@ -0,0 +1,7 @@
+export async function executeOpenQrCommand(services) {
+  const result = await services.getRemotes().adminActions.openQrBrowserServer();
+  return {
+    ok: Boolean(result?.ok),
+    message: String(result?.message || 'Commande executee.'),
+  };
+}

package/server/term/srv/commands/samsungDetectCommand.js

@@ -0,0 +1,52 @@
+import {
+  getSamsungDeviceMac,
+  pickSamsungDevice,
+} from '../../../remotes/samsung/device-config.js';
+
+function mapDevice(device) {
+  return {
+    name: String(device?.name || '').trim(),
+    model: String(device?.model || '').trim(),
+    host: String(device?.ip || '').trim(),
+    mac: getSamsungDeviceMac(device),
+  };
+}
+
+export async function executeSamsungDetectCommand(services) {
+  try {
+    const samsungConfig = services.getConfig().samsungTv;
+    const devices = await services.getRemotes().samsung.discoverDevices();
+    const selected = pickSamsungDevice(
+      devices,
+      samsungConfig.alwaysAutoResolve
+        ? {...samsungConfig, host: '', mac: ''}
+        : samsungConfig,
+    );
+
+    if (!selected) {
+      if (!devices.length) {
+        return {
+          ok: false,
+          message: 'Aucune TV Samsung detectee.',
+        };
+      }
+
+      return {
+        ok: false,
+        message: 'Plusieurs TV Samsung detectees. Configurez samsungTv.host ou samsungTv.mac, ou desactivez alwaysAutoResolve.',
+        data: devices.map(mapDevice),
+      };
+    }
+
+    return {
+      ok: true,
+      message: 'TV Samsung detectee.',
+      data: mapDevice(selected),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: String(error?.message || error || 'Decouverte Samsung impossible.'),
+    };
+  }
+}

package/server/term/srv/commands/serviceCommand.js

@@ -0,0 +1,25 @@
+export async function executeServiceCommand(services, args = {}) {
+  if (args.action === 'install') {
+    return services.getApplicationDaemonService().install();
+  }
+
+  if (args.action === 'disable') {
+    return services.getApplicationDaemonService().disable();
+  }
+
+  if (args.action === 'uninstall') {
+    return services.getApplicationDaemonService().uninstall();
+  }
+
+  if (args.action === 'restart') {
+    return services.getApplicationDaemonService().restart({
+      cause: 'user',
+      source: 'cli',
+    });
+  }
+
+  return {
+    ok: false,
+    message: `Action service inconnue: ${String(args.action || '').trim() || '(vide)'}`,
+  };
+}

package/server/term/srv/commands/systemConfigCommand.js

@@ -0,0 +1,7 @@
+export async function executeSystemConfigCommand(services) {
+  return {
+    ok: true,
+    message: 'Configuration système.',
+    data: services.getSystemConfig(),
+  };
+}

package/server/term/srv/commands/tasksCommand.js

@@ -0,0 +1,24 @@
+function mapTask(task) {
+  const dueAt = task?.dueAt || null;
+  const dueInMs = dueAt ? new Date(dueAt).getTime() - Date.now() : null;
+
+  return {
+    id: task?.id || null,
+    name: task?.name || 'unnamed-task',
+    running: Boolean(task?.running),
+    delayMs: Number.isFinite(task?.delayMs) ? task.delayMs : null,
+    dueAt,
+    dueInMs: Number.isFinite(dueInMs) ? dueInMs : null,
+  };
+}
+
+export async function executeTasksCommand(services) {
+  return {
+    ok: true,
+    message: 'Etat du task manager.',
+    data: {
+      now: new Date().toISOString(),
+      tasks: services.getTaskManager().getTasksSnapshot().map(mapTask),
+    },
+  };
+}

package/server/term/srv/commands/tokensCommand.js

@@ -0,0 +1,15 @@
+export async function executeTokensCommand(services) {
+  const tokens = Array.from(
+    services.getPersistence().entryTokenDao.loadEntryTokens(),
+    ([token, createdAt]) => ({
+      token,
+      createdAt,
+    }),
+  );
+
+  return {
+    ok: true,
+    message: 'Tokens chargés.',
+    data: tokens,
+  };
+}

package/server/term/srv/executeCliCommand.js

@@ -0,0 +1,44 @@
+import {executeConfigCommand} from './commands/configCommand.js';
+import {executeHelpCommand} from './commands/helpCommand.js';
+import {executeInfoCommand} from './commands/infoCommand.js';
+import {executeOpenQrCommand} from './commands/openQrCommand.js';
+import {executeSamsungDetectCommand} from './commands/samsungDetectCommand.js';
+import {executeServiceCommand} from './commands/serviceCommand.js';
+import {executeSystemConfigCommand} from './commands/systemConfigCommand.js';
+import {executeTasksCommand} from './commands/tasksCommand.js';
+import {executeTokensCommand} from './commands/tokensCommand.js';
+import {formatCliCommand} from '../cli/parseCliArgs.js';
+
+const commandHandlers = {
+  help: executeHelpCommand,
+  'open-qr': executeOpenQrCommand,
+  qr: executeOpenQrCommand,
+  config: executeConfigCommand,
+  'sys-config': executeSystemConfigCommand,
+  info: executeInfoCommand,
+  'system-info': executeInfoCommand,
+  service: executeServiceCommand,
+  tasks: executeTasksCommand,
+  'task-manager': executeTasksCommand,
+  'samsung-detect': executeSamsungDetectCommand,
+  tokens: executeTokensCommand,
+};
+
+export async function executeCliCommand(services, command) {
+  const commandName = String(command?.name || '').trim();
+  const args = command?.args || {};
+
+  if (!commandName) {
+    return executeHelpCommand(services, args);
+  }
+
+  const handler = commandHandlers[commandName];
+  if (handler) {
+    return handler(services, args);
+  }
+
+  return {
+    ok: false,
+    message: `Commande inconnue: ${formatCliCommand(command)}`,
+  };
+}

package/server/term/srv/executeCliRequest.js

@@ -0,0 +1,38 @@
+import {executeCliCommand} from './executeCliCommand.js';
+import {
+  createLogger,
+  withCliLogStream,
+} from '../../application/logger.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('cli:request');
+  return log;
+}
+
+function normalizeVerbosity(options = {}) {
+  return Math.max(0, Number.parseInt(options.verbosity || 0, 10) || 0);
+}
+
+function getVerbosityLogLevel(verbosity) {
+  return verbosity > 1 ? 'trace' : 'debug';
+}
+
+export async function withCliVerbosity(options = {}, callback, onLog = null) {
+  const log = getModuleLog();
+  const verbosity = normalizeVerbosity(options);
+  log.trace({verbosity}, 'Application verbosite CLI');
+
+  return verbosity > 0
+    ? withCliLogStream(getVerbosityLogLevel(verbosity), onLog, callback)
+    : callback();
+}
+
+export async function executeCliRequest(services, command, options = {}, onLog = null) {
+  const log = getModuleLog();
+  log.debug({
+    command: command?.name || '',
+    verbosity: normalizeVerbosity(options),
+  }, 'Execution requete CLI');
+  return withCliVerbosity(options, () => executeCliCommand(services, command), onLog);
+}

package/server/term/srv/startCliServer.js

@@ -0,0 +1,140 @@
+import net from 'node:net';
+import {getCliSocketAdapter} from '../cliSocket.js';
+import {executeCliRequest} from './executeCliRequest.js';
+import {createLogger} from '../../application/logger.js';
+
+function writeResponse(socket, payload) {
+  socket.end(`${JSON.stringify(payload)}\n`);
+}
+
+function normalizeVerbosity(options = {}) {
+  return Math.max(0, Number.parseInt(options.verbosity || 0, 10) || 0);
+}
+
+function writeFrame(socket, payload) {
+  socket.write(`${JSON.stringify(payload)}\n`);
+}
+
+function writeResult(socket, result, options = {}) {
+  if (normalizeVerbosity(options) <= 0) {
+    writeResponse(socket, result);
+    return;
+  }
+
+  writeFrame(socket, {
+    type: 'result',
+    result,
+  });
+  socket.end();
+}
+
+function parseRequest(input) {
+  try {
+    const payload = JSON.parse(String(input || '').trim() || '{}');
+    const command = payload.command && typeof payload.command === 'object' ? payload.command : {name: String(payload.command || '').trim(), args: {}};
+    const options = payload.options && typeof payload.options === 'object' ? payload.options : {};
+    return {
+      command,
+      options,
+    };
+  } catch (_error) {
+    return {
+      command: {name: String(input || '').trim(), args: {}},
+      options: {},
+    };
+  }
+}
+
+const log = createLogger('cli');
+
+export async function startCliServer(services) {
+
+  const cliSocket = getCliSocketAdapter();
+  const socketPath = cliSocket.getCliSocketPath();
+  let isClosed = false;
+
+  function closeServer() {
+    if (isClosed) {
+      return;
+    }
+
+    isClosed = true;
+    server.close();
+    cliSocket.cleanupCliServerSocket(socketPath);
+  }
+
+  cliSocket.prepareCliServerSocket(socketPath);
+
+  const server = net.createServer({allowHalfOpen: true}, (socket) => {
+    let input = '';
+    let handled = false;
+    socket.setEncoding('utf8');
+    log.trace('Connexion CLI ouverte');
+
+    async function handleCommand() {
+      if (handled) {
+        return;
+      }
+
+      handled = true;
+
+      try {
+        const request = parseRequest(input);
+        log.debug({
+          command: request.command?.name || '',
+          verbosity: normalizeVerbosity(request.options),
+        }, 'Commande CLI recue');
+        const result = await executeCliRequest(services, request.command, request.options, (entry) => {
+          writeFrame(socket, {
+            type: 'log',
+            entry,
+          });
+        });
+        log.debug({
+          command: request.command?.name || '',
+          ok: Boolean(result?.ok),
+        }, 'Commande CLI terminee');
+        writeResult(socket, result, request.options);
+      } catch (error) {
+        log.error({err: error}, 'Erreur execution commande CLI');
+        writeResponse(socket, {
+          ok: false,
+          message: `Erreur CLI: ${error.message}`,
+        });
+      }
+    }
+
+    socket.on('data', (chunk) => {
+      input += chunk;
+    });
+
+    socket.on('end', () => {
+      void handleCommand();
+    });
+    socket.on('close', () => {
+      log.trace('Connexion CLI fermee');
+    });
+  });
+
+  server.once('close', () => {
+    cliSocket.cleanupCliServerSocket(socketPath);
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(socketPath, () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+
+  cliSocket.secureCliServerSocket(socketPath);
+
+  log.info({socketPath}, 'Interface CLI locale prête');
+
+  return {
+    close() {
+      closeServer();
+    },
+  };
+}

package/server/utils/createRandomToken.js

@@ -0,0 +1,11 @@
+import crypto from "node:crypto";
+import {clamp} from "../../utils/math.js";
+
+export function createRandomToken(length) {
+    const safeLength = clamp(Math.floor(length), 8, 128);
+    let token = '';
+    while (token.length < safeLength) {
+        token += crypto.randomBytes(24).toString('base64url');
+    }
+    return token.slice(0, safeLength);
+}

package/server/utils/env.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import dotenv from 'dotenv';
+
+export function expandHomePath(value) {
+  const raw = String(value || '').trim();
+  if (!raw) {
+    return '';
+  }
+  if (raw === '~') {
+    return os.homedir();
+  }
+  if (raw.startsWith('~/')) {
+    return path.join(os.homedir(), raw.slice(2));
+  }
+  return raw;
+}
+
+export function resolveConfigDir(explicitConfigDir = '') {
+  const configuredDir = expandHomePath(explicitConfigDir);
+  if (configuredDir) {
+    return path.resolve(process.cwd(), configuredDir);
+  }
+  if (process.env.NODE_ENV === 'test') {
+    return path.join(os.tmpdir(), 'remote-mouse');
+  }
+  return path.join(os.homedir(), '.config', 'remote-mouse');
+}
+
+export function resolvePathFromConfigDir(value, configDir, fallbackName = '') {
+  const rawValue = String(value || '').trim();
+  const rawFallback = String(fallbackName || '').trim();
+  const candidate = expandHomePath(rawValue || rawFallback);
+
+  if (!candidate) {
+    return '';
+  }
+
+  if (path.isAbsolute(candidate)) {
+    return candidate;
+  }
+
+  return path.resolve(configDir, candidate);
+}
+
+export function resolveEnvFilePath({ appRoot, configDir = '', explicitEnvFilePath = '' }) {
+  const cwdEnvFilePath = path.join(process.cwd(), '.env');
+  const appEnvFilePath = appRoot ? path.join(appRoot, '.env') : '';
+  const configDirEnvFilePath = configDir ? path.join(configDir, '.env') : '';
+  const explicitResolved = explicitEnvFilePath
+    ? path.resolve(process.cwd(), expandHomePath(explicitEnvFilePath))
+    : '';
+
+  if (explicitResolved && fs.existsSync(explicitResolved)) {
+    return explicitResolved;
+  }
+  if (configDirEnvFilePath && fs.existsSync(configDirEnvFilePath)) {
+    return configDirEnvFilePath;
+  }
+  if (fs.existsSync(cwdEnvFilePath)) {
+    return cwdEnvFilePath;
+  }
+  if (appEnvFilePath && fs.existsSync(appEnvFilePath)) {
+    return appEnvFilePath;
+  }
+  return '';
+}
+
+export function loadEnvFile(envFilePath) {
+  if (!envFilePath) {
+    return;
+  }
+  dotenv.config({ path: envFilePath, override: false });
+}
+
+export function readPackageVersion(packageJsonPath, fallback = 'unknown') {
+  try {
+    const raw = fs.readFileSync(packageJsonPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return String(parsed?.version || '').trim() || fallback;
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+export function readRaw(key, fallback = '') {
+  if (Object.prototype.hasOwnProperty.call(process.env, key)
+    && process.env[key] !== undefined
+    && process.env[key] !== null
+    && process.env[key] !== '') {
+    return String(process.env[key]);
+  }
+  return fallback;
+}
+
+export function readString(key, fallback = '') {
+  return readRaw(key, fallback).trim();
+}
+
+export function readOptionalString(key) {
+  if (!Object.prototype.hasOwnProperty.call(process.env, key)
+    || process.env[key] === undefined
+    || process.env[key] === null
+    || process.env[key] === '') {
+    return undefined;
+  }
+  return String(process.env[key]).trim();
+}
+
+export function readNumber(
+  key,
+  fallback,
+  { min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY } = {},
+) {
+  const raw = readRaw(key, String(fallback));
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    return fallback;
+  }
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+
+export function readOptionalNumber(key) {
+  if (!Object.prototype.hasOwnProperty.call(process.env, key)
+    || process.env[key] === undefined
+    || process.env[key] === null
+    || process.env[key] === '') {
+    return undefined;
+  }
+  const value = Number(process.env[key]);
+  return Number.isFinite(value) ? value : undefined;
+}
+
+export function readBoolean(key, fallback = false) {
+  const raw = readRaw(key, fallback ? 'true' : 'false').toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
+export function readOptionalBoolean(key) {
+  if (!Object.prototype.hasOwnProperty.call(process.env, key)
+    || process.env[key] === undefined
+    || process.env[key] === null
+    || process.env[key] === '') {
+    return undefined;
+  }
+  const normalized = String(process.env[key]).trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}

package/server/utils/git.js

@@ -0,0 +1,13 @@
+import { execFile } from 'node:child_process';
+
+export function runGit(args) {
+  return new Promise((resolve) => {
+    execFile('git', args, { timeout: 5000 }, (error, stdout = '', stderr = '') => {
+      resolve({
+        ok: !error,
+        stdout: String(stdout).trim(),
+        stderr: String(stderr).trim(),
+      });
+    });
+  });
+}

package/server/utils/http.js

@@ -0,0 +1,7 @@
+export async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return response.json();
+}

package/server/utils/network.js

@@ -0,0 +1,45 @@
+import os from 'node:os';
+import { execFileAsync } from './process.js';
+
+export function getLanIp(forcedHost = '') {
+  if (forcedHost) {
+    return forcedHost;
+  }
+
+  try {
+    const interfaces = os.networkInterfaces();
+    for (const interfaceName of Object.keys(interfaces)) {
+      const addresses = interfaces[interfaceName] || [];
+      for (const address of addresses) {
+        if (address.family === 'IPv4' && !address.internal) {
+          return address.address;
+        }
+      }
+    }
+  } catch (_error) {
+    console.warn("Impossible de detecter l'IP LAN automatiquement, fallback sur localhost.");
+  }
+
+  return '127.0.0.1';
+}
+
+export function getPublicUrl(port, protocol = 'http', forcedHost = '') {
+  return `${protocol}://${getLanIp(forcedHost)}:${port}`;
+}
+
+export async function pingHost(host, timeoutMs = 2000) {
+  const normalizedHost = String(host || '').trim();
+  if (!normalizedHost) {
+    return false;
+  }
+
+  const args = process.platform === 'win32'
+    ? ['-n', '1', normalizedHost]
+    : ['-c', '1', normalizedHost];
+
+  const result = await execFileAsync('ping', args, {
+    timeout: Math.max(250, Number(timeoutMs) || 2000),
+  });
+
+  return Boolean(result.ok);
+}