@velor/remote-mouse 6.4.8

package/server/services/update-manager/CommandUpdateSource.js

@@ -0,0 +1,70 @@
+import {execShell} from '../../utils/process.js';
+
+function normalizeCommandResult(rawText, fallbackTitle) {
+  const text = String(rawText || '').trim();
+  if (!text) {
+    return { hasUpdate: false };
+  }
+
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === 'object') {
+      const hasUpdate = Boolean(parsed.hasUpdate);
+      if (!hasUpdate) {
+        return { hasUpdate: false };
+      }
+      const key = String(parsed.key || `cmd:${Date.now()}`);
+      const title = String(parsed.title || fallbackTitle);
+      const message = String(parsed.message || 'Mise a jour detectee.');
+      const ttlMs = Number(parsed.ttlMs) > 0 ? Number(parsed.ttlMs) : 8000;
+      return { hasUpdate, key, title, message, ttlMs };
+    }
+  } catch (_error) {
+    // Fall back to plain text protocol.
+  }
+
+  const token = text.toLowerCase();
+  if (token === '0' || token === 'false' || token === 'no' || token === 'none') {
+    return { hasUpdate: false };
+  }
+
+  if (token === '1' || token === 'true' || token === 'yes' || token === 'update' || token === 'has_update') {
+    return {
+      hasUpdate: true,
+      key: `cmd:${Date.now()}`,
+      title: fallbackTitle,
+      message: 'Mise a jour detectee.',
+      ttlMs: 8000,
+    };
+  }
+
+  return {
+    hasUpdate: true,
+    key: `cmd:${text.slice(0, 64)}`,
+    title: fallbackTitle,
+    message: text,
+    ttlMs: 8000,
+  };
+}
+
+export class CommandUpdateSource {
+  constructor({checkCommand, timeoutSec, logger = null}) {
+    this.checkCommand = String(checkCommand || '').trim();
+    this.timeoutMs = Math.max(1000, Math.round(Number(timeoutSec || 20) * 1000));
+    this.logger = logger;
+  }
+
+  async check() {
+    if (!this.checkCommand) {
+      return { hasUpdate: false };
+    }
+
+    const result = await execShell(this.checkCommand, this.timeoutMs);
+    if (!result.ok) {
+      this.logger?.warn({stderr: result.stderr, stdout: result.stdout}, 'Update check command failed');
+      return { hasUpdate: false };
+    }
+
+    return normalizeCommandResult(result.stdout, 'Mise a jour detectee (commande)');
+  }
+}

package/server/services/update-manager/NpmUpdateSource.js

@@ -0,0 +1,34 @@
+import { fetchJson } from '../../utils/http.js';
+import { isVersionGreater } from '../../utils/semver.js';
+
+export class NpmUpdateSource {
+  constructor({ packageName, currentVersion }) {
+    this.packageName = packageName;
+    this.currentVersion = currentVersion;
+  }
+
+  async check() {
+    if (!this.packageName || !this.currentVersion) {
+      return { hasUpdate: false };
+    }
+
+    const url = `https://registry.npmjs.org/${encodeURIComponent(this.packageName)}/latest`;
+    const data = await fetchJson(url);
+    const latest = String(data.version || '').trim();
+    if (!latest) {
+      return { hasUpdate: false };
+    }
+
+    if (!isVersionGreater(latest, this.currentVersion)) {
+      return { hasUpdate: false };
+    }
+
+    return {
+      hasUpdate: true,
+      key: `npm:${latest}`,
+      title: 'Mise a jour disponible',
+      message: `Version ${latest} disponible (actuelle: ${this.currentVersion}).`,
+      ttlMs: 8000,
+    };
+  }
+}

package/server/services/update-manager/buildNpmGlobalUpdateCommand.js

@@ -0,0 +1,15 @@
+function shellQuote(value) {
+  const text = String(value || '').trim();
+  if (!text) {
+    return '';
+  }
+  return `'${text.replace(/'/g, `'\"'\"'`)}'`;
+}
+
+export function buildNpmGlobalUpdateCommand(packageName) {
+  const name = String(packageName || '').trim();
+  if (!name) {
+    return '';
+  }
+  return `npm update -g ${shellQuote(name)}`;
+}

package/server/services/update-manager/chooseUpdateCheckSource.js

@@ -0,0 +1,20 @@
+import { NpmUpdateSource } from './NpmUpdateSource.js';
+import { CommandUpdateSource } from './CommandUpdateSource.js';
+import {createLogger} from '../../application/logger.js';
+
+export function chooseUpdateCheckSource({getSystemConfig}) {
+  const updateConfig = getSystemConfig().updateCheck || {};
+  const checkCommand = String(updateConfig.checkCommand || '').trim();
+  const commandSource = new CommandUpdateSource({
+    checkCommand,
+    timeoutSec: updateConfig.checkTimeoutSec,
+    logger: createLogger('update-check'),
+  });
+  const npmSource = new NpmUpdateSource({
+    packageName: updateConfig.packageName,
+    currentVersion: updateConfig.currentVersion,
+  });
+  const checkSource = checkCommand ? commandSource : npmSource;
+
+  return () => checkSource.check();
+}

package/server/services/update-manager/chooseUpdateInstallSource.js

@@ -0,0 +1,5 @@
+import {resolveInstallUpdateCommand} from './resolveInstallUpdateCommand.js';
+
+export function chooseUpdateInstallSource({getSystemConfig}) {
+  return resolveInstallUpdateCommand({getSystemConfig});
+}

package/server/services/update-manager/createUpdateManager.js

@@ -0,0 +1,109 @@
+import {chooseUpdateCheckSource} from "./chooseUpdateCheckSource.js";
+import {chooseUpdateInstallSource} from "./chooseUpdateInstallSource.js";
+import {
+    PUBSUB_EVENT_UPDATE_AVAILABLE,
+    PUBSUB_EVENT_UPDATE_CHECK,
+    PUBSUB_EVENT_UPDATE_ERROR,
+    PUBSUB_SERVICE_UPDATE_MANAGER
+} from "../pubsub/serviceEventConstants.js";
+import {createLogger} from '../../application/logger.js';
+
+export function createUpdateManager(services) {
+    const log = createLogger('update-check');
+    let lastKey = '';
+    let lastInstallCommand = '';
+    let lastResult = null;
+
+    function publishState(type = PUBSUB_EVENT_UPDATE_CHECK) {
+        services.getEvents().publishState(PUBSUB_SERVICE_UPDATE_MANAGER, {
+            enabled: Boolean(services.getConfig().updateCheck?.enabled),
+            lastKey,
+            lastInstallCommand,
+            lastResult,
+        }, {type});
+    }
+
+    async function check() {
+        if (!services.getConfig().updateCheck?.enabled) {
+            lastResult = {
+                checked: true,
+                hasUpdate: false,
+                skipped: true,
+                checkedAt: new Date().toISOString(),
+            };
+            publishState(PUBSUB_EVENT_UPDATE_CHECK);
+            return {
+                checked: true,
+                hasUpdate: false,
+            };
+        }
+
+        try {
+            const result = await chooseUpdateCheckSource(services)();
+
+            if (!result?.hasUpdate || !result.key || result.key === lastKey) {
+                log.debug('Update check: no update');
+                lastResult = {
+                    checked: true,
+                    hasUpdate: false,
+                    checkedAt: new Date().toISOString(),
+                };
+                publishState(PUBSUB_EVENT_UPDATE_CHECK);
+                return {
+                    checked: true,
+                    hasUpdate: false,
+                };
+            }
+
+            lastKey = result.key;
+            lastResult = {
+                checked: true,
+                hasUpdate: true,
+                key: result.key,
+                title: result.title,
+                message: result.message,
+                ttlMs: result.ttlMs || 8000,
+                checkedAt: new Date().toISOString(),
+            };
+            publishState(PUBSUB_EVENT_UPDATE_AVAILABLE);
+            return {
+                checked: true,
+                hasUpdate: true,
+                key: result.key,
+            };
+        } catch (_error) {
+            log.error({err: _error}, 'Update check: error');
+            lastResult = {
+                checked: false,
+                hasUpdate: false,
+                checkedAt: new Date().toISOString(),
+                error: _error.message,
+            };
+            publishState(PUBSUB_EVENT_UPDATE_ERROR);
+            return {
+                checked: false,
+                hasUpdate: false,
+            };
+        }
+    }
+
+    async function update() {
+        const install = chooseUpdateInstallSource(services);
+        lastInstallCommand = String(install.command || '');
+        log.info({installCommand: lastInstallCommand}, 'Exécution commande install update');
+        const result = await install();
+        if (result.ok) {
+            log.info('Install update terminée avec succès');
+            return result;
+        }
+        if (result?.status === 'failed') {
+            log.error({details: result.details}, 'Install update en échec');
+        }
+        return result;
+    }
+
+    return {
+        check,
+        update,
+    }
+}

package/server/services/update-manager/resolveInstallUpdateCommand.js

@@ -0,0 +1,42 @@
+import {execShell} from '../../utils/process.js';
+import {truncateText} from '../../utils/truncateText.js';
+import {buildNpmGlobalUpdateCommand} from './buildNpmGlobalUpdateCommand.js';
+
+export function resolveInstallUpdateCommand({getSystemConfig}) {
+  const updateConfig = getSystemConfig().updateCheck || {};
+  const installCommand = String(updateConfig.installCommand || '').trim();
+  const resolvedCommand = installCommand || buildNpmGlobalUpdateCommand(updateConfig.packageName);
+  const timeoutMs = Math.max(10_000, Number(updateConfig.installTimeoutSec || 0) * 1000);
+
+  const runInstall = async () => {
+    if (!resolvedCommand) {
+      return {
+        ok: false,
+        status: 'no-command',
+        message: 'Aucune commande update disponible.',
+      };
+    }
+
+    const result = await execShell(resolvedCommand, timeoutMs);
+    if (result.ok) {
+      return {
+        ok: true,
+        status: 'completed',
+        message: 'Installation terminee.',
+        command: resolvedCommand,
+      };
+    }
+
+    const details = truncateText(result.stderr || result.stdout || 'Erreur inconnue');
+    return {
+      ok: false,
+      status: 'failed',
+      message: `Echec installation: ${details}`,
+      details,
+      command: resolvedCommand,
+    };
+  };
+
+  runInstall.command = resolvedCommand;
+  return runInstall;
+}

package/server/term/cli/executeLocalServiceCommand.js

@@ -0,0 +1,42 @@
+import {createLazy} from "../../../utils/createLazy.js";
+import {getSystemConfig} from "../../services/config/index.js";
+import {createPersistence} from "../../services/persistence/index.js";
+import {createApplicationDaemonService} from "../../services/application/createApplicationDaemonService.js";
+import {formatCliCommand} from "./parseCliArgs.js";
+
+function createLocalDaemonServices() {
+    const services = {};
+    services.getSystemConfig = createLazy(() => getSystemConfig());
+    services.getPersistence = createLazy(() => createPersistence(services));
+    services.getApplicationDaemonService = createLazy(() => createApplicationDaemonService(services));
+    return services;
+}
+
+export async function executeLocalServiceCommand(command) {
+    const services = createLocalDaemonServices();
+    const action = String(command?.args?.action || '').trim();
+
+    if (action === 'install') {
+        return services.getApplicationDaemonService().install();
+    }
+
+    if (action === 'disable') {
+        return services.getApplicationDaemonService().disable();
+    }
+
+    if (action === 'uninstall') {
+        return services.getApplicationDaemonService().uninstall();
+    }
+
+    if (action === 'restart') {
+        return services.getApplicationDaemonService().restart({
+            cause: 'user',
+            source: 'cli',
+        });
+    }
+
+    return {
+        ok: false,
+        message: `Commande inconnue: ${formatCliCommand(command)}`,
+    };
+}

package/server/term/cli/getCliSocketPath.js

@@ -0,0 +1,5 @@
+import {getCliSocketAdapter} from '../cliSocket.js';
+
+export function getCliSocketPath() {
+  return getCliSocketAdapter().getCliSocketPath();
+}

package/server/term/cli/parseCliArgs.js

@@ -0,0 +1,110 @@
+import yargs from 'yargs/yargs.js';
+
+function normalizeVerbosity(value) {
+  return Math.max(0, Number.parseInt(value || 0, 10) || 0);
+}
+
+function joinParts(parts) {
+  return parts
+    .map((part) => String(part ?? '').trim())
+    .filter(Boolean)
+    .join(' ');
+}
+
+export function parseCliArgs(args) {
+  let command = {
+    name: '',
+    args: {},
+  };
+
+  const parsed = yargs(args)
+    .scriptName('remote-mouse')
+    .help(false)
+    .version(false)
+    .parserConfiguration({
+      'camel-case-expansion': false,
+      'strip-aliased': true,
+      'strip-dashed': true,
+    })
+    .option('verbosity', {
+      type: 'number',
+      default: 0,
+      describe: 'Niveau de verbosite des logs pour la commande CLI.',
+    })
+    .count('v')
+    .command('help', false, () => {}, () => {
+      command = {name: 'help', args: {}};
+    })
+    .command('config [action] [path] [value..]', false, (builder) => builder
+      .positional('action', {type: 'string'})
+      .positional('path', {type: 'string'})
+      .positional('value', {array: true}), (argv) => {
+      command = {
+        name: 'config',
+        args: {
+          action: String(argv.action || '').trim(),
+          path: String(argv.path || '').trim(),
+          value: joinParts(argv.value || []),
+        },
+      };
+    })
+    .command('sys-config', false, () => {}, () => {
+      command = {name: 'sys-config', args: {}};
+    })
+    .command('info', false, () => {}, () => {
+      command = {name: 'info', args: {}};
+    })
+    .command('system-info', false, () => {}, () => {
+      command = {name: 'system-info', args: {}};
+    })
+    .command('service <action>', false, (builder) => builder
+      .positional('action', {type: 'string'}), (argv) => {
+      command = {
+        name: 'service',
+        args: {
+          action: String(argv.action || '').trim(),
+        },
+      };
+    })
+    .command('tasks', false, () => {}, () => {
+      command = {name: 'tasks', args: {}};
+    })
+    .command('task-manager', false, () => {}, () => {
+      command = {name: 'task-manager', args: {}};
+    })
+    .command('samsung-detect', false, () => {}, () => {
+      command = {name: 'samsung-detect', args: {}};
+    })
+    .command('tokens', false, () => {}, () => {
+      command = {name: 'tokens', args: {}};
+    })
+    .command('open-qr', false, () => {}, () => {
+      command = {name: 'open-qr', args: {}};
+    })
+    .command('qr', false, () => {}, () => {
+      command = {name: 'qr', args: {}};
+    })
+    .parse();
+
+  return {
+    command,
+    options: {
+      verbosity: Math.max(normalizeVerbosity(parsed.verbosity), normalizeVerbosity(parsed.v)),
+    },
+  };
+}
+
+export function formatCliCommand(command) {
+  if (!command || typeof command !== 'object') {
+    return '';
+  }
+
+  if (command.name === 'config') {
+    return joinParts(['config', command.args?.action, command.args?.path, command.args?.value]);
+  }
+  if (command.name === 'service') {
+    return joinParts(['service', command.args?.action]);
+  }
+
+  return String(command.name || '').trim();
+}

package/server/term/cli/printCliResult.js

@@ -0,0 +1,18 @@
+export function printCliLog(entry) {
+    const data = entry.data === undefined ? '' : ` ${JSON.stringify(entry.data)}`;
+    console.error(`[${entry.at}] ${entry.level} ${entry.scope}: ${entry.message}${data}`);
+}
+
+export function printCliResult(result) {
+    if (Array.isArray(result?.logs)) {
+        for (const entry of result.logs) {
+            printCliLog(entry);
+        }
+    }
+    if (result?.data !== undefined) {
+        console.log(JSON.stringify(result.data, null, 2));
+    }
+    if (result?.message) {
+        console.log(result.message);
+    }
+}

package/server/term/cli/runCliCmd.js

@@ -0,0 +1,50 @@
+import {parseCliArgs} from "./parseCliArgs.js";
+import {executeLocalServiceCommand} from "./executeLocalServiceCommand.js";
+import {printCliLog, printCliResult} from "./printCliResult.js";
+import {sendCliCommand} from "./sendCliCommand.js";
+import {withCliVerbosity} from "../srv/executeCliRequest.js";
+
+function isLocalServiceCommand(command) {
+    return command?.name === 'service'
+        && ['install', 'disable', 'uninstall', 'restart'].includes(String(command.args?.action || '').trim());
+}
+
+export async function runCliCmd(args) {
+    const normalizedArgs = args[0] === 'cli'
+        ? args.slice(1)
+        : args;
+    const {command, options} = parseCliArgs(normalizedArgs);
+
+    if (!command?.name || command.name === 'help') {
+        console.log('Usage:');
+        console.log('  remote-mouse              Demarre le serveur');
+        console.log('  remote-mouse config       Affiche la configuration persistée effective');
+        console.log('  remote-mouse service install Installe le daemon/service local');
+        console.log('  remote-mouse service disable Desactive le daemon/service local');
+        console.log('  remote-mouse service uninstall Desinstalle le daemon/service local');
+        console.log('  remote-mouse service restart Redemarre le daemon/service local');
+        console.log('  remote-mouse tasks        Affiche les informations du task manager');
+        console.log('  remote-mouse task-manager Alias de tasks');
+        console.log('  remote-mouse info --verbosity 2 Affiche les capacites serveur avec logs detailles');
+        console.log('  remote-mouse system-info  Alias de info');
+        console.log('  remote-mouse tokens       Liste les tokens en base');
+        console.log('  remote-mouse open-qr      Envoie une commande au service deja demarre');
+        console.log('  remote-mouse qr           Alias de open-qr');
+        process.exit(0);
+    }
+
+    try {
+        if (isLocalServiceCommand(command)) {
+            const result = await withCliVerbosity(options, () => executeLocalServiceCommand(command), printCliLog);
+            printCliResult(result);
+            process.exit(result?.ok ? 0 : 1);
+        }
+
+        const result = await sendCliCommand(command, options, {onLog: printCliLog});
+        printCliResult(result);
+        process.exit(result?.ok ? 0 : 1);
+    } catch (error) {
+        console.error(`Impossible de contacter le service: ${error.message}`);
+        process.exit(1);
+    }
+}

package/server/term/cli/sendCliCommand.js

@@ -0,0 +1,76 @@
+import net from 'node:net';
+import {getCliSocketAdapter} from '../cliSocket.js';
+
+function parseResponseLine(line, state, onLog) {
+  const payload = JSON.parse(line);
+  if (payload?.type === 'log') {
+    if (typeof onLog === 'function') {
+      onLog(payload.entry);
+    }
+    return;
+  }
+
+  if (payload?.type === 'result') {
+    state.result = payload.result;
+    return;
+  }
+
+  state.result = payload;
+}
+
+export async function sendCliCommand(command, options = {}, {onLog = null} = {}) {
+  const cliSocket = getCliSocketAdapter();
+  const socketPath = cliSocket.getCliSocketPath();
+
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    const state = {
+      buffer: '',
+      result: undefined,
+    };
+
+    socket.setEncoding('utf8');
+
+    socket.on('connect', () => {
+      socket.end(JSON.stringify({
+        command,
+        options,
+      }));
+    });
+
+    socket.on('data', (chunk) => {
+      state.buffer += chunk;
+      const lines = state.buffer.split('\n');
+      state.buffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          parseResponseLine(trimmed, state, onLog);
+        }
+      }
+    });
+
+    socket.on('end', () => {
+      try {
+        const remaining = state.buffer.trim();
+        if (remaining) {
+          parseResponseLine(remaining, state, onLog);
+        }
+        resolve(state.result || {});
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+    socket.on('error', (error) => {
+      const staleSocketRemoved = cliSocket.cleanupCliClientConnectionError(socketPath, error);
+
+      if (staleSocketRemoved) {
+        reject(new Error(`Service indisponible. Le socket stale a été supprimé: ${socketPath}`));
+        return;
+      }
+
+      reject(error);
+    });
+  });
+}

package/server/term/cliSocket.js

@@ -0,0 +1,29 @@
+import * as darwinCliSocket from '../os/darwin/cliSocket.js';
+import * as linuxCliSocket from '../os/linux/cliSocket.js';
+import * as win32CliSocket from '../os/win32/cliSocket.js';
+
+const unsupportedCliSocket = {
+  getCliSocketPath() {
+    return linuxCliSocket.getCliSocketPath();
+  },
+  prepareCliServerSocket: linuxCliSocket.prepareCliServerSocket,
+  cleanupCliServerSocket: linuxCliSocket.cleanupCliServerSocket,
+  secureCliServerSocket: linuxCliSocket.secureCliServerSocket,
+  cleanupCliClientConnectionError: linuxCliSocket.cleanupCliClientConnectionError,
+};
+
+export function getCliSocketAdapter(platform = process.platform) {
+  if (platform === 'win32') {
+    return win32CliSocket;
+  }
+
+  if (platform === 'darwin') {
+    return darwinCliSocket;
+  }
+
+  if (platform === 'linux') {
+    return linuxCliSocket;
+  }
+
+  return unsupportedCliSocket;
+}