@velor/remote-mouse 6.4.8

package/scripts/install-windows.ps1

@@ -0,0 +1,369 @@
+[CmdletBinding()]
+param(
+  [Alias('y')]
+  [switch]$Yes,
+
+  [string]$PackageName = $env:REMOTE_MOUSE_NPM_PACKAGE,
+
+  [string]$ConfigDir = $env:REMOTE_MOUSE_CONFIG_DIR,
+
+  [int]$Port = $(if ($env:REMOTE_MOUSE_PORT) { [int]$env:REMOTE_MOUSE_PORT } else { 3000 }),
+
+  [switch]$Https,
+
+  [switch]$NoHttps,
+
+  [switch]$GenerateCert,
+
+  [switch]$NoGenerateCert,
+
+  [string]$SslKeyPath = $env:REMOTE_MOUSE_SSL_KEY_PATH,
+
+  [string]$SslCertPath = $env:REMOTE_MOUSE_SSL_CERT_PATH,
+
+  [switch]$InstallService,
+
+  [switch]$NoService
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Get-DefaultPackageName {
+  $fallback = '@velor/remote-mouse'
+  if ([string]::IsNullOrWhiteSpace($PSCommandPath)) {
+    return $fallback
+  }
+
+  $scriptDir = Split-Path -Parent $PSCommandPath
+  $projectRoot = Split-Path -Parent $scriptDir
+  $packageJsonPath = Join-Path $projectRoot 'package.json'
+
+  if (Test-Path -LiteralPath $packageJsonPath) {
+    try {
+      $packageJson = Get-Content -LiteralPath $packageJsonPath -Raw | ConvertFrom-Json
+      if ($packageJson.name) {
+        return [string]$packageJson.name
+      }
+    } catch {
+      return $fallback
+    }
+  }
+
+  return $fallback
+}
+
+if ([string]::IsNullOrWhiteSpace($PackageName)) {
+  $PackageName = Get-DefaultPackageName
+}
+
+if ([string]::IsNullOrWhiteSpace($ConfigDir)) {
+  $ConfigDir = Join-Path $env:APPDATA 'remote-mouse'
+}
+
+function Write-Step {
+  param([string]$Message)
+  Write-Host ''
+  Write-Host $Message
+}
+
+function Confirm-Step {
+  param([string]$Prompt)
+
+  if ($Yes) {
+    Write-Host "$Prompt [Y/n] y"
+    return $true
+  }
+
+  $answer = Read-Host "$Prompt [y/N]"
+  return $answer -match '^(y|yes)$'
+}
+
+function Read-Value {
+  param(
+    [string]$Prompt,
+    [string]$DefaultValue = ''
+  )
+
+  if ($Yes) {
+    Write-Host "$Prompt [$DefaultValue] $DefaultValue"
+    return $DefaultValue
+  }
+
+  if ($DefaultValue) {
+    $value = Read-Host "$Prompt [$DefaultValue]"
+    if ([string]::IsNullOrWhiteSpace($value)) {
+      return $DefaultValue
+    }
+    return $value
+  }
+
+  return Read-Host $Prompt
+}
+
+function Test-Command {
+  param([string]$Name)
+  return [bool](Get-Command $Name -ErrorAction SilentlyContinue)
+}
+
+function Install-WithWinget {
+  param(
+    [string]$PackageId,
+    [string]$Label
+  )
+
+  if (-not (Test-Command 'winget')) {
+    throw "Missing $Label and winget is not available. Install $Label manually, then rerun this script."
+  }
+
+  if (Confirm-Step "Install $Label with winget?") {
+    winget install --id $PackageId --exact --accept-package-agreements --accept-source-agreements
+  } else {
+    throw "Cannot continue without $Label."
+  }
+}
+
+function Ensure-Node {
+  $missingNode = -not (Test-Command 'node')
+  $missingNpm = -not (Test-Command 'npm')
+
+  if (-not $missingNode -and -not $missingNpm) {
+    Write-Step "Node: $(node --version)"
+    Write-Step "npm: $(npm --version)"
+    return
+  }
+
+  if ($missingNode) {
+    Write-Warning 'node was not found in PATH.'
+  }
+  if ($missingNpm) {
+    Write-Warning 'npm was not found in PATH.'
+  }
+
+  Install-WithWinget -PackageId 'OpenJS.NodeJS.LTS' -Label 'Node.js LTS'
+
+  if (-not (Test-Command 'node') -or -not (Test-Command 'npm')) {
+    throw 'Node.js was installed, but node/npm are still not available in this terminal. Open a new terminal and rerun this script.'
+  }
+}
+
+function Ensure-BuildTools {
+  if (Test-Command 'cl') {
+    return
+  }
+
+  Write-Warning 'Microsoft C++ build tools were not found in PATH.'
+  if (Test-Command 'winget') {
+    if (Confirm-Step 'Install Microsoft Visual Studio Build Tools with winget?') {
+      winget install --id Microsoft.VisualStudio.2022.BuildTools --exact --accept-package-agreements --accept-source-agreements --override '--quiet --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended'
+      return
+    }
+  }
+
+  Write-Warning 'Native npm modules may require Microsoft C++ Build Tools. Install them manually if npm install fails.'
+}
+
+function Ensure-Python {
+  if (Test-Command 'python') {
+    return
+  }
+
+  if (Test-Command 'py') {
+    return
+  }
+
+  Write-Warning 'Python was not found in PATH.'
+  if (Test-Command 'winget') {
+    if (Confirm-Step 'Install Python with winget?') {
+      winget install --id Python.Python.3.12 --exact --accept-package-agreements --accept-source-agreements
+      return
+    }
+  }
+
+  Write-Warning 'Native npm modules may require Python. Install it manually if npm install fails.'
+}
+
+function Ensure-PowerShell {
+  if ($PSVersionTable.PSVersion.Major -lt 5) {
+    throw 'PowerShell 5 or newer is required.'
+  }
+}
+
+function Install-NpmPackage {
+  Write-Step "Installing npm package: $PackageName"
+  npm install -g $PackageName
+
+  if (-not (Test-Command 'remote-mouse')) {
+    throw 'remote-mouse CLI was not found in PATH after npm installation. Open a new terminal or check npm global bin path with: npm prefix -g'
+  }
+}
+
+function New-CookieSecret {
+  $bytes = New-Object byte[] 32
+  $rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
+  try {
+    $rng.GetBytes($bytes)
+    return -join ($bytes | ForEach-Object { $_.ToString('x2') })
+  } finally {
+    $rng.Dispose()
+  }
+}
+
+function Configure-Https {
+  $config = @{
+    Https = 'false'
+    KeyPath = ''
+    CertPath = ''
+  }
+
+  if ($NoHttps) {
+    return $config
+  }
+
+  if (-not $Https -and -not (Confirm-Step 'Serve Remote Mouse over HTTPS?')) {
+    return $config
+  }
+
+  $config.Https = 'true'
+  $certDir = Join-Path $ConfigDir 'certs'
+
+  if ($GenerateCert -or (-not $NoGenerateCert -and (Confirm-Step 'Generate a local self-signed certificate?'))) {
+    New-Item -ItemType Directory -Force -Path $certDir | Out-Null
+    $cert = New-SelfSignedCertificate `
+      -DnsName @('localhost', 'remote-mouse.local') `
+      -CertStoreLocation 'Cert:\CurrentUser\My' `
+      -KeyAlgorithm RSA `
+      -KeyLength 2048 `
+      -KeyExportPolicy Exportable `
+      -NotAfter (Get-Date).AddYears(1)
+
+    $pfxPath = Join-Path $certDir 'remote-mouse.pfx'
+    $password = ConvertTo-SecureString -String (New-CookieSecret) -AsPlainText -Force
+    Export-PfxCertificate -Cert $cert -FilePath $pfxPath -Password $password | Out-Null
+
+    if (-not (Test-Command 'openssl')) {
+      Install-WithWinget -PackageId 'ShiningLight.OpenSSL' -Label 'OpenSSL'
+    }
+
+    $keyPath = Join-Path $certDir 'remote-mouse.key'
+    $certPath = Join-Path $certDir 'remote-mouse.crt'
+    $plainPassword = (New-Object System.Net.NetworkCredential('', $password)).Password
+    openssl pkcs12 -in $pfxPath -nocerts -nodes -out $keyPath -passin "pass:$plainPassword"
+    openssl pkcs12 -in $pfxPath -clcerts -nokeys -out $certPath -passin "pass:$plainPassword"
+
+    $config.KeyPath = $keyPath
+    $config.CertPath = $certPath
+    return $config
+  }
+
+  $keyPathInput = $SslKeyPath
+  if ([string]::IsNullOrWhiteSpace($keyPathInput)) {
+    $keyPathInput = Read-Value 'Path to the existing PEM private key'
+  }
+
+  $certPathInput = $SslCertPath
+  if ([string]::IsNullOrWhiteSpace($certPathInput)) {
+    $certPathInput = Read-Value 'Path to the existing PEM certificate'
+  }
+
+  if (-not (Test-Path -LiteralPath $keyPathInput)) {
+    throw "Private key not found: $keyPathInput"
+  }
+  if (-not (Test-Path -LiteralPath $certPathInput)) {
+    throw "Certificate not found: $certPathInput"
+  }
+
+  $config.KeyPath = $keyPathInput
+  $config.CertPath = $certPathInput
+  return $config
+}
+
+function Write-EnvFile {
+  param([hashtable]$HttpsConfig)
+
+  New-Item -ItemType Directory -Force -Path $ConfigDir | Out-Null
+  $envFile = Join-Path $ConfigDir '.env'
+
+  if (Test-Path -LiteralPath $envFile) {
+    if (-not (Confirm-Step "Overwrite existing $envFile?")) {
+      Write-Step "Keeping existing $envFile."
+      return
+    }
+  }
+
+  $cookieSecret = New-CookieSecret
+  $dbPath = Join-Path $ConfigDir 'remote-mouse.sqlite3'
+  $content = @"
+PORT=$Port
+SERVER_HOST=
+CONFIG_DIR=$ConfigDir
+PERSISTENCE_DB_PATH=$dbPath
+ENV_FILE_PATH=$envFile
+
+HTTPS=$($HttpsConfig.Https)
+SSL_KEY_PATH=$($HttpsConfig.KeyPath)
+SSL_CERT_PATH=$($HttpsConfig.CertPath)
+
+ENTRY_PATH_ENABLED=true
+ENTRY_PATH_FIXED=
+ENTRY_PATH_TOKEN_LENGTH=24
+ENTRY_PATH_ROTATE_INTERVAL_MIN=60
+ENTRY_PATH_GRACE_MIN=120
+
+SESSION_COOKIE_NAME=remote_mouse_session
+SESSION_COOKIE_SECRET=$cookieSecret
+SESSION_COOKIE_MAX_AGE_DAYS=7
+SOCKET_EVENT_MAX_AGE_MS=1200
+
+LOG_LEVEL=info
+LOG_FORMAT=json
+ADMIN_ACTIONS_ENABLED=true
+SERVICE_NAME=remote-mouse
+SERVICE_RESTART_COMMAND=
+"@
+
+  Set-Content -LiteralPath $envFile -Value $content -Encoding UTF8
+  Write-Step "Wrote $envFile"
+}
+
+function Install-Service {
+  if ($NoService) {
+    return $false
+  }
+
+  if (-not $InstallService -and -not (Confirm-Step 'Install the user service?')) {
+    return $false
+  }
+
+  remote-mouse service install
+  remote-mouse service restart
+  return $true
+}
+
+function Main {
+  Write-Step 'Remote Mouse Windows installer'
+  Write-Step "Package: $PackageName"
+  Write-Step "Config directory: $ConfigDir"
+
+  Ensure-PowerShell
+  Ensure-Node
+  Ensure-BuildTools
+  Ensure-Python
+  Install-NpmPackage
+  $httpsConfig = Configure-Https
+  Write-EnvFile -HttpsConfig $httpsConfig
+  $serviceInstalled = Install-Service
+
+  Write-Step 'Installation complete.'
+  if ($serviceInstalled) {
+    Write-Host 'Service installed. Use Task Scheduler or remote-mouse service restart to manage it.'
+  } else {
+    Write-Host 'Start Remote Mouse with: remote-mouse'
+  }
+
+  if ($httpsConfig.Https -eq 'true') {
+    Write-Host 'Browsers will warn about the self-signed certificate until it is trusted locally.'
+    Write-Host 'Use the browser advanced/details option to continue to the site.'
+  }
+}
+
+Main

package/server/application/createApplicationLifecycle.js

@@ -0,0 +1,15 @@
+import {createApplicationStart} from './start.js';
+import {createApplicationShutdown} from './shutdown.js';
+import {ensureApplicationLifecycleState} from './state.js';
+
+export function createApplicationLifecycle(services) {
+    const state = ensureApplicationLifecycleState(services);
+    const shutdown = createApplicationShutdown(services);
+    state.shutdown = shutdown;
+    const start = createApplicationStart(services);
+
+    return {
+        start,
+        shutdown,
+    };
+}

package/server/application/logger.js

@@ -0,0 +1,216 @@
+import pino from 'pino';
+import {Writable} from 'node:stream';
+import {getSystemConfig} from "../services/config/index.js";
+
+const maxStoredLogs = 400;
+const maxStoredMessageLength = 2_000;
+const maxStoredDataLength = 8_000;
+const recentLogs = [];
+const cliLogSubscribers = new Set();
+let rootLogger = null;
+let temporaryLogLevel = '';
+
+const levels = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+};
+
+const levelNamesByValue = Object.fromEntries(
+  Object.entries(levels).map(([name, value]) => [value, name]),
+);
+
+function getLevelValue(level) {
+  return levels[String(level || '').trim()] ?? levels.info;
+}
+
+function safeClone(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized !== 'string') {
+      return undefined;
+    }
+    if (serialized.length <= maxStoredDataLength) {
+      return JSON.parse(serialized);
+    }
+
+    return {
+      truncated: true,
+      preview: `${serialized.slice(0, maxStoredDataLength)}...`,
+    };
+  } catch (_error) {
+    const text = String(value);
+    return text.length <= maxStoredDataLength
+      ? text
+      : `${text.slice(0, maxStoredDataLength)}...`;
+  }
+}
+
+function mapPinoRecord(record) {
+  const {time, level, scope, msg, pid: _pid, hostname: _hostname, ...data} = record || {};
+  const levelName = levelNamesByValue[level] || String(level || 'info');
+  return {
+    at: typeof time === 'string' ? time : new Date(time || Date.now()).toISOString(),
+    scope: String(scope || 'app'),
+    level: levelName,
+    message: String(msg || '').slice(0, maxStoredMessageLength),
+    data: Object.keys(data).length > 0 ? safeClone(data) : undefined,
+  };
+}
+
+function publishCliLog(entry) {
+  for (const subscriber of cliLogSubscribers) {
+    if (getLevelValue(entry.level) < subscriber.minLevel) {
+      continue;
+    }
+
+    subscriber.write(entry);
+  }
+}
+
+function parseLogLines(buffer, chunk, onRecord) {
+  const lines = `${buffer}${String(chunk || '')}`.split('\n');
+  const nextBuffer = lines.pop() || '';
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    try {
+      onRecord(JSON.parse(trimmed));
+    } catch (_error) {
+      // Non-JSON transport output is intentionally ignored by structured transports.
+    }
+  }
+
+  return nextBuffer;
+}
+
+function createRecentLogTransport() {
+  let buffer = '';
+
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      buffer = parseLogLines(buffer, chunk, (record) => {
+        const entry = mapPinoRecord(record);
+        recentLogs.push(entry);
+        if (recentLogs.length > maxStoredLogs) {
+          recentLogs.splice(0, recentLogs.length - maxStoredLogs);
+        }
+      });
+      callback();
+    },
+  });
+}
+
+function createCliLogTransport() {
+  let buffer = '';
+
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      buffer = parseLogLines(buffer, chunk, (record) => {
+        publishCliLog(mapPinoRecord(record));
+      });
+      callback();
+    },
+  });
+}
+
+function createDestination(logFormat) {
+  if (logFormat === 'flat' || logFormat === 'pretty') {
+    return pino.transport({
+      target: 'pino-pretty',
+      options: {
+        colorize: false,
+        singleLine: true,
+        translateTime: 'SYS:standard',
+        ignore: 'pid,hostname',
+      },
+    });
+  }
+
+  return undefined;
+}
+
+function syncLoggerConfig(logger) {
+  const nextLevel = temporaryLogLevel || getSystemConfig()?.logging?.level;
+  if (nextLevel && logger.level !== nextLevel) {
+    logger.level = nextLevel;
+  }
+}
+
+function buildRootLogger() {
+  const systemConfig = getSystemConfig();
+  const systemLogLevel = systemConfig?.logging?.level || 'info';
+  const systemLogFormat = systemConfig?.logging?.format || 'json';
+  const systemDestination = createDestination(systemLogFormat) || process.stdout;
+  const logger = pino({
+    level: systemLogLevel,
+    timestamp: pino.stdTimeFunctions.isoTime,
+  }, pino.multistream([
+    {level: systemLogLevel, stream: systemDestination},
+    {level: 'trace', stream: createRecentLogTransport()},
+    {level: 'trace', stream: createCliLogTransport()},
+  ]));
+
+  return logger;
+}
+
+export function bootstrapLogger() {
+  if (!rootLogger) {
+    rootLogger = buildRootLogger();
+  } else {
+    syncLoggerConfig(rootLogger);
+  }
+  return rootLogger;
+}
+
+export function createLogger(scope) {
+  const logger = bootstrapLogger();
+  syncLoggerConfig(logger);
+  return logger.child({ scope });
+}
+
+export function getRecentLogs(limit = 200) {
+  const safeLimit = Math.max(1, Math.min(1000, Math.round(Number(limit) || 200)));
+  return recentLogs.slice(-safeLimit);
+}
+
+export async function withTemporaryLoggerLevel(level, callback) {
+  const logger = bootstrapLogger();
+  const previousTemporaryLogLevel = temporaryLogLevel;
+  const previousLevel = logger.level;
+  temporaryLogLevel = String(level || '').trim();
+  if (temporaryLogLevel) {
+    logger.level = temporaryLogLevel;
+  }
+
+  try {
+    return await callback();
+  } finally {
+    temporaryLogLevel = previousTemporaryLogLevel;
+    logger.level = previousTemporaryLogLevel || previousLevel;
+  }
+}
+
+export async function withCliLogStream(level, onLog, callback) {
+  const subscriber = {
+    minLevel: getLevelValue(level),
+    write: typeof onLog === 'function' ? onLog : () => {},
+  };
+  cliLogSubscribers.add(subscriber);
+
+  try {
+    return await withTemporaryLoggerLevel(level, callback);
+  } finally {
+    cliLogSubscribers.delete(subscriber);
+  }
+}

package/server/application/shutdown.js

@@ -0,0 +1,81 @@
+import {ensureApplicationLifecycleState} from './state.js';
+import {createLogger} from './logger.js';
+
+export function createApplicationShutdown(services) {
+  const log = createLogger('server');
+
+  async function runShutdownStep(label, action) {
+    try {
+      await action();
+    } catch (error) {
+      log.error({err: error}, label);
+    }
+  }
+
+  return async function shutdown(signal) {
+    const state = ensureApplicationLifecycleState(services);
+    const serverBundle = services.getServer();
+    const httpServer = serverBundle.server;
+    const io = serverBundle.io;
+    const taskManager = services.getTaskManager();
+    const qrOverlay = services.getQrOverlay();
+    const sseService = services.getSseService();
+
+    if (state.shuttingDown) {
+      return;
+    }
+
+    state.shuttingDown = true;
+    log.info({signal}, 'Arret du serveur');
+    services.getPersistence().restartLogDao?.createLifecycleEvent({
+      eventAt: Date.now(),
+      eventType: 'stop',
+      cause: 'user',
+      source: signal ? `signal:${signal}` : 'shutdown',
+      status: 'completed',
+      details: {
+        signal: signal || null,
+        graceful: true,
+        processUptimeSec: Math.floor(process.uptime()),
+      },
+    });
+
+    await Promise.allSettled([
+      runShutdownStep('Erreur a l arret du task manager', () => taskManager.stop()),
+      runShutdownStep('Erreur a l arret de l observateur de configuration', () => state.stopConfigObserver()),
+      runShutdownStep('Erreur a l arret de l observateur de notifications', () => state.stopNotificationObserver()),
+      runShutdownStep('Erreur a l arret de l observateur de resolution ecran', () => state.stopDisplaySizeObserver()),
+      runShutdownStep('Erreur a l arret de l observateur du QR overlay', () => state.stopQrOverlayRefreshObserver()),
+      runShutdownStep('Erreur a l arret de l observateur du survol QR overlay', () => state.stopQrOverlayHoverObserver()),
+      runShutdownStep('Erreur a la fermeture du socket CLI', () => state.cliServer?.close()),
+      runShutdownStep('Erreur a la fermeture du QR overlay', () => qrOverlay.close()),
+      runShutdownStep('Erreur a la fermeture des connexions SSE', () => sseService?.closeAll?.()),
+      runShutdownStep('Erreur a la fermeture de Socket.IO', () => new Promise((resolve) => {
+        io?.close?.(() => resolve());
+      })),
+    ]);
+
+    try {
+      serverBundle.closeIdleConnections?.();
+    } catch (error) {
+      log.error({err: error}, 'Erreur a la fermeture des connexions HTTP inactives');
+    }
+
+    await new Promise((resolve) => {
+      const forceShutdownTimer = setTimeout(() => {
+        try {
+          serverBundle.destroyConnections?.();
+        } catch (error) {
+          log.error({err: error}, 'Erreur a la destruction forcee des connexions HTTP');
+        }
+      }, 1_500);
+
+      httpServer.close(() => {
+        clearTimeout(forceShutdownTimer);
+        resolve();
+      });
+    });
+
+    process.exit(0);
+  };
+}