@velor/remote-mouse 6.4.8

package/server/os/linux/cliSocket.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function getSocketName() {
+  const uid = typeof process.getuid === 'function' ? process.getuid() : 'default';
+  return `remote-mouse-${uid}.sock`;
+}
+
+function removeStaleSocket(socketPath) {
+  try {
+    fs.unlinkSync(socketPath);
+  } catch (_error) {
+    // Ignore missing or stale socket cleanup issues.
+  }
+}
+
+export function getCliSocketPath() {
+  return path.join(os.tmpdir(), getSocketName());
+}
+
+export function prepareCliServerSocket(socketPath) {
+  removeStaleSocket(socketPath);
+}
+
+export function cleanupCliServerSocket(socketPath) {
+  removeStaleSocket(socketPath);
+}
+
+export function secureCliServerSocket(socketPath) {
+  try {
+    fs.chmodSync(socketPath, 0o600);
+  } catch (_error) {
+    // Best effort.
+  }
+}
+
+export function cleanupCliClientConnectionError(socketPath, error) {
+  if (error?.code !== 'ECONNREFUSED') {
+    return false;
+  }
+
+  try {
+    if (!fs.existsSync(socketPath)) {
+      return false;
+    }
+
+    fs.unlinkSync(socketPath);
+    return true;
+  } catch (_cleanupError) {
+    return false;
+  }
+}

package/server/os/linux/process.js

@@ -0,0 +1,69 @@
+import {createLogger} from '../../application/logger.js';
+import {execFileAsync} from '../../utils/process.js';
+
+const LINUX_COMMAND_EXTRA_PATHS = [
+  '/snap/bin',
+  '/var/lib/snapd/snap/bin',
+  '/usr/local/bin',
+  '/usr/bin',
+  '/bin',
+];
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('os:linux:process');
+  return log;
+}
+
+export function getLinuxCommandLookupPath(basePath = process.env.PATH || '') {
+  const entries = String(basePath || '')
+    .split(':')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+  for (const extraPath of LINUX_COMMAND_EXTRA_PATHS) {
+    if (!entries.includes(extraPath)) {
+      entries.push(extraPath);
+    }
+  }
+
+  return entries.join(':');
+}
+
+export async function resolveLinuxCommand(command) {
+  const log = getModuleLog();
+  const normalizedCommand = String(command || '').trim();
+  if (!normalizedCommand) {
+    return '';
+  }
+
+  const lookupPath = getLinuxCommandLookupPath();
+  const result = await execFileAsync('which', [normalizedCommand], {
+    timeout: 2000,
+    env: {
+      ...process.env,
+      PATH: lookupPath,
+    },
+  });
+
+  if (!result.ok) {
+    log.trace({command: normalizedCommand, lookupPath}, 'Commande Linux introuvable');
+    return '';
+  }
+
+  const resolvedCommand = result.stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean) || normalizedCommand;
+
+  log.debug({
+    command: normalizedCommand,
+    resolvedCommand,
+    lookupPath,
+  }, 'Commande Linux resolue');
+  return resolvedCommand;
+}
+
+export async function commandExists(command) {
+  return Boolean(await resolveLinuxCommand(command));
+}

package/server/os/linux/screen.js

@@ -0,0 +1,58 @@
+import {execFileAsync} from '../../utils/process.js';
+
+function normalizeScreenSize(screen) {
+  const width = Number(screen?.width);
+  const height = Number(screen?.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+
+  return {
+    width: Math.round(width),
+    height: Math.round(height),
+  };
+}
+
+export function parseXrandrScreenSize(output) {
+  const match = String(output || '').match(/\bcurrent\s+(\d+)\s*x\s*(\d+)\b/i);
+  if (!match) {
+    return null;
+  }
+
+  return normalizeScreenSize({
+    width: match[1],
+    height: match[2],
+  });
+}
+
+export function parseXdpyinfoScreenSize(output) {
+  const match = String(output || '').match(/\bdimensions:\s*(\d+)x(\d+)\s+pixels\b/i);
+  if (!match) {
+    return null;
+  }
+
+  return normalizeScreenSize({
+    width: match[1],
+    height: match[2],
+  });
+}
+
+export async function resolveLinuxScreenSize() {
+  const xrandr = await execFileAsync('xrandr', ['--current'], {timeout: 1500});
+  if (xrandr.ok) {
+    const screen = parseXrandrScreenSize(xrandr.stdout);
+    if (screen) {
+      return screen;
+    }
+  }
+
+  const xdpyinfo = await execFileAsync('xdpyinfo', [], {timeout: 1500});
+  if (xdpyinfo.ok) {
+    const screen = parseXdpyinfoScreenSize(xdpyinfo.stdout);
+    if (screen) {
+      return screen;
+    }
+  }
+
+  return null;
+}

package/server/os/linux/systemd.js

@@ -0,0 +1,139 @@
+import {
+    getEntrypoint,
+    getPlatformKind,
+    getSystemdUnitPath,
+    isDaemonProcess,
+    shellQuote,
+} from "../../services/application/utils.js";
+import fs from "node:fs";
+import path from "node:path";
+import {
+    execFileAsync,
+    spawnDetached
+} from "../../utils/process.js";
+
+export function buildSystemdUnit({entrypoint, nodePath}) {
+    const nodeBinDir = path.dirname(String(nodePath || process.execPath));
+    const environmentPath = [nodeBinDir, '/usr/local/bin', '/usr/bin', '/bin']
+        .filter(Boolean)
+        .join(':');
+
+    return [
+        '[Unit]',
+        'Description=Remote Mouse Server',
+        'After=graphical-session.target network-online.target',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        'Type=simple',
+        `ExecStart=${entrypoint}`,
+        'Restart=on-failure',
+        'RestartSec=2',
+        `Environment=PATH=${environmentPath}`,
+        'Environment=NODE_ENV=production',
+        'Environment=REMOTE_MOUSE_DAEMON=1',
+        'PassEnvironment=DISPLAY WAYLAND_DISPLAY XAUTHORITY DBUS_SESSION_BUS_ADDRESS',
+        '',
+        '[Install]',
+        'WantedBy=default.target',
+        '',
+    ].join('\n');
+}
+
+export async function installLinuxDaemon(serviceName) {
+    const unitPath = getSystemdUnitPath(serviceName);
+    fs.mkdirSync(path.dirname(unitPath), {recursive: true});
+    fs.writeFileSync(unitPath, buildSystemdUnit({
+        entrypoint: getEntrypoint(),
+        nodePath: process.execPath,
+    }), 'utf8');
+
+    const reload = await execFileAsync('systemctl', ['--user', 'daemon-reload'], {timeout: 15000});
+    if (!reload.ok) {
+        return {ok: false, message: reload.stderr || 'systemctl --user daemon-reload a echoue.'};
+    }
+
+    const enable = await execFileAsync('systemctl', ['--user', 'enable', '--now', serviceName], {timeout: 30000});
+    if (!enable.ok) {
+        return {ok: false, message: enable.stderr || `Impossible d'installer ${serviceName}.`};
+    }
+
+    return {
+        ok: true,
+        message: `Service ${serviceName} installe via systemd utilisateur.`,
+    };
+}
+
+export async function disableLinuxDaemon(serviceName) {
+    const result = await execFileAsync('systemctl', ['--user', 'disable', '--now', serviceName], {timeout: 30000});
+    if (!result.ok) {
+        return {ok: false, message: result.stderr || `Impossible de desactiver ${serviceName}.`};
+    }
+
+    return {
+        ok: true,
+        message: `Service ${serviceName} desactive.`,
+    };
+}
+
+export async function uninstallLinuxDaemon(serviceName) {
+    const unitPath = getSystemdUnitPath(serviceName);
+
+    await execFileAsync('systemctl', ['--user', 'disable', '--now', serviceName], {timeout: 30000});
+
+    try {
+        fs.unlinkSync(unitPath);
+    } catch (error) {
+        if (error?.code !== 'ENOENT') {
+            return {
+                ok: false,
+                message: `Impossible de supprimer ${unitPath}.`,
+                details: {message: error.message},
+            };
+        }
+    }
+
+    const reload = await execFileAsync('systemctl', ['--user', 'daemon-reload'], {timeout: 15000});
+    if (!reload.ok) {
+        return {ok: false, message: reload.stderr || 'systemctl --user daemon-reload a echoue.'};
+    }
+
+    await execFileAsync('systemctl', ['--user', 'reset-failed', serviceName], {timeout: 10000});
+
+    return {
+        ok: true,
+        message: `Service ${serviceName} desinstalle.`,
+    };
+}
+
+export async function restartLinuxDaemon(serviceName) {
+    const spawned = await spawnDetached(
+        'bash',
+        ['-lc', `sleep 0.8; systemctl --user restart ${shellQuote(serviceName)}`],
+    );
+
+    if (!spawned) {
+        return {
+            ok: false,
+            message: 'Impossible de lancer la commande de redemarrage.',
+            details: {message: 'spawn systemctl failed'},
+        };
+    }
+
+    return {
+        ok: true,
+        message: `Redemarrage demande pour ${serviceName}.`,
+    };
+}
+
+export async function getLinuxDaemonInfo(serviceName) {
+    const result = await execFileAsync('systemctl', ['--user', 'status', serviceName], {timeout: 5000});
+
+    return {
+        serviceName,
+        platform: process.platform,
+        platformKind: getPlatformKind(),
+        runningAsDaemon: isDaemonProcess(),
+        installed: result.ok,
+    };
+}

package/server/os/linux/url.js

@@ -0,0 +1,17 @@
+import {spawnDetached} from '../../utils/process.js';
+import {commandExists} from './process.js';
+
+export async function openLinuxUrl(url) {
+  const safeUrl = String(url || '').trim();
+  if (!safeUrl) {
+    return false;
+  }
+
+  if (await commandExists('xdg-open')) {
+    return spawnDetached('xdg-open', [safeUrl]);
+  }
+  if (await commandExists('gio')) {
+    return spawnDetached('gio', ['open', safeUrl]);
+  }
+  return false;
+}

package/server/os/linux/windows.js

@@ -0,0 +1,144 @@
+import {execFileAsync} from '../../utils/process.js';
+import {commandExists} from './process.js';
+
+export function parseWindowIdsFromWmctrl(output, {classes = [], names = []} = {}) {
+  const patterns = [...classes, ...names].map((value) => String(value).toLowerCase());
+
+  return output
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => patterns.some((pattern) => line.toLowerCase().includes(pattern)))
+    .map((line) => line.split(/\s+/)[0])
+    .filter((id) => /^0x[0-9a-f]+$/i.test(id));
+}
+
+export async function findWindows(query = {}) {
+  if (await commandExists('wmctrl')) {
+    const result = await execFileAsync('wmctrl', ['-lx']);
+    if (result.ok) {
+      const ids = parseWindowIdsFromWmctrl(result.stdout, query);
+      if (ids.length > 0) {
+        return ids;
+      }
+    }
+  }
+
+  if (!(await commandExists('xdotool'))) {
+    return [];
+  }
+
+  const matches = [];
+  for (const className of query.classes ?? []) {
+    matches.push((await execFileAsync('xdotool', ['search', '--onlyvisible', '--class', className])).stdout);
+    matches.push((await execFileAsync('xdotool', ['search', '--class', className])).stdout);
+  }
+  for (const name of query.names ?? []) {
+    matches.push((await execFileAsync('xdotool', ['search', '--onlyvisible', '--name', name])).stdout);
+    matches.push((await execFileAsync('xdotool', ['search', '--name', name])).stdout);
+  }
+
+  return matches
+    .join('\n')
+    .split('\n')
+    .map((value) => value.trim())
+    .filter((value) => /^\d+$/.test(value));
+}
+
+export async function activateWindow(windowId, {maximize = false} = {}) {
+  if (await commandExists('wmctrl')) {
+    const activated = await execFileAsync('wmctrl', ['-ia', String(windowId)]);
+    if (!activated.ok) {
+      return false;
+    }
+    if (maximize) {
+      await execFileAsync('wmctrl', ['-ir', String(windowId), '-b', 'add,maximized_vert,maximized_horz']);
+    }
+    return true;
+  }
+
+  if (!(await commandExists('xdotool'))) {
+    return false;
+  }
+
+  const activated = await execFileAsync('xdotool', ['windowactivate', '--sync', String(windowId)]);
+  if (!activated.ok) {
+    return false;
+  }
+
+  await execFileAsync('xdotool', ['windowraise', String(windowId)]);
+  if (maximize && await commandExists('wmctrl')) {
+    await execFileAsync('wmctrl', ['-ir', String(windowId), '-b', 'add,maximized_vert,maximized_horz']);
+  }
+  return true;
+}
+
+export async function maximizeWindow(windowId) {
+  if (!(await commandExists('wmctrl'))) {
+    return false;
+  }
+
+  return (await execFileAsync('wmctrl', ['-ir', String(windowId), '-b', 'add,maximized_vert,maximized_horz'])).ok;
+}
+
+export async function restoreWindow(windowId) {
+  if (await commandExists('wmctrl')) {
+    return (await execFileAsync('wmctrl', ['-ir', String(windowId), '-b', 'remove,maximized_vert,maximized_horz'])).ok;
+  }
+
+  return false;
+}
+
+export async function isWindowMaximized(windowId) {
+  if (!(await commandExists('xprop'))) {
+    return false;
+  }
+
+  const result = await execFileAsync('xprop', ['-id', String(windowId), '_NET_WM_STATE']);
+  return result.ok
+    && result.stdout.includes('_NET_WM_STATE_MAXIMIZED_VERT')
+    && result.stdout.includes('_NET_WM_STATE_MAXIMIZED_HORZ');
+}
+
+export async function toggleWindow(windowId) {
+  if (await isWindowMaximized(windowId)) {
+    return restoreWindow(windowId);
+  }
+  return maximizeWindow(windowId);
+}
+
+export async function closeWindow(windowId) {
+  if (await commandExists('wmctrl')) {
+    return (await execFileAsync('wmctrl', ['-ic', String(windowId)])).ok;
+  }
+
+  if (await commandExists('xdotool')) {
+    return (await execFileAsync('xdotool', ['windowclose', String(windowId)])).ok;
+  }
+
+  return false;
+}
+
+export async function getActiveWindowId() {
+  if (await commandExists('xdotool')) {
+    const result = await execFileAsync('xdotool', ['getactivewindow']);
+    if (result.ok) {
+      const id = result.stdout.trim();
+      if (/^\d+$/.test(id)) {
+        return id;
+      }
+    }
+  }
+
+  if (await commandExists('xprop')) {
+    const result = await execFileAsync('xprop', ['-root', '_NET_ACTIVE_WINDOW']);
+    if (result.ok) {
+      const match = result.stdout.match(/0x[0-9a-f]+/i);
+      if (match) {
+        return match[0];
+      }
+    }
+  }
+
+  return '';
+}

package/server/os/win32/app.js

@@ -0,0 +1,66 @@
+import {execFileAsync} from '../../utils/process.js';
+import {buildForegroundWindowPowerShell, buildTitleActivationPowerShell} from './powershell.js';
+import {commandExistsWin32} from './process.js';
+import {findFirstAvailable} from "../../../utils/predicates.js";
+
+export async function activateWin32Titles(titles = []) {
+  if (!titles.length) {
+    return false;
+  }
+
+  const result = await execFileAsync('powershell', [
+    '-NoProfile',
+    '-Command',
+    buildTitleActivationPowerShell(titles),
+  ]);
+
+  return result.ok && result.stdout.trim() === 'true';
+}
+
+export async function resolveWin32App(spec = {}) {
+  const win = spec.win32 || {};
+  const command = await findFirstAvailable(win.commands, commandExistsWin32);
+  if (!command) {
+    return null;
+  }
+
+  return {
+    command,
+    titles: win.windowTitles ?? [],
+  };
+}
+
+export async function openOrFocusWin32App(spec) {
+  const resolved = await resolveWin32App(spec);
+  if (!resolved) {
+    return false;
+  }
+
+  if (await activateWin32Titles(resolved.titles)) {
+    return true;
+  }
+
+  return (await execFileAsync('powershell', ['-NoProfile', '-Command', `Start-Process ${resolved.command}`])).ok;
+}
+
+export async function toggleWin32AppWindow(spec) {
+  const resolved = await resolveWin32App(spec);
+  if (!resolved) {
+    return false;
+  }
+  if (!(await activateWin32Titles(resolved.titles))) {
+    return false;
+  }
+  return (await execFileAsync('powershell', ['-NoProfile', '-Command', buildForegroundWindowPowerShell('toggle')])).ok;
+}
+
+export async function closeWin32AppWindow(spec) {
+  const resolved = await resolveWin32App(spec);
+  if (!resolved) {
+    return false;
+  }
+  if (!(await activateWin32Titles(resolved.titles))) {
+    return false;
+  }
+  return (await execFileAsync('powershell', ['-NoProfile', '-Command', buildForegroundWindowPowerShell('close')])).ok;
+}

package/server/os/win32/cliSocket.js

@@ -0,0 +1,15 @@
+const cliPipePath = '\\\\.\\pipe\\remote-mouse';
+
+export function getCliSocketPath() {
+  return cliPipePath;
+}
+
+export function prepareCliServerSocket() {}
+
+export function cleanupCliServerSocket() {}
+
+export function secureCliServerSocket() {}
+
+export function cleanupCliClientConnectionError() {
+  return false;
+}

package/server/os/win32/powershell.js

@@ -0,0 +1,70 @@
+export function buildForegroundWindowPowerShell(mode) {
+  if (mode === 'toggle') {
+    return `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public static class NativeWin {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern bool IsZoomed(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+}
+"@
+$hwnd = [NativeWin]::GetForegroundWindow()
+if ($hwnd -eq [IntPtr]::Zero) { exit 1 }
+if ([NativeWin]::IsZoomed($hwnd)) {
+  [void][NativeWin]::ShowWindow($hwnd, 9)
+} else {
+  [void][NativeWin]::ShowWindow($hwnd, 3)
+}
+`.trim();
+  }
+
+  return `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public static class NativeWin {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+}
+"@
+$hwnd = [NativeWin]::GetForegroundWindow()
+if ($hwnd -eq [IntPtr]::Zero) { exit 1 }
+[void][NativeWin]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero)
+`.trim();
+}
+
+export function buildTitleActivationPowerShell(titles = []) {
+  const clauses = titles
+    .map((title) => String(title).replace(/"/g, '\\"'))
+    .map((title) => `if ($ws.AppActivate("${title}")) { "true"; exit 0 }`)
+    .join('; ');
+
+  return `$ws = New-Object -ComObject WScript.Shell; ${clauses}; exit 1`;
+}
+
+export function buildQrOverlayPowerShellScript({qrPath, size, posX, posY}) {
+  const escapedQrPath = String(qrPath).replace(/\\/g, '\\\\');
+  return [
+    'Add-Type -AssemblyName System.Windows.Forms',
+    'Add-Type -AssemblyName System.Drawing',
+    '$form = New-Object Windows.Forms.Form',
+    "$form.StartPosition = 'Manual'",
+    '$form.FormBorderStyle = [System.Windows.Forms.FormBorderStyle]::None',
+    '$form.TopMost = $true',
+    '$form.ShowInTaskbar = $false',
+    `$form.ClientSize = New-Object System.Drawing.Size(${size}, ${size})`,
+    `$form.Left = ${posX}`,
+    `$form.Top = ${posY}`,
+    '$form.Padding = New-Object Windows.Forms.Padding(0)',
+    '$picture = New-Object Windows.Forms.PictureBox',
+    '$picture.Margin = New-Object Windows.Forms.Padding(0)',
+    '$picture.Padding = New-Object Windows.Forms.Padding(0)',
+    '$picture.Dock = [System.Windows.Forms.DockStyle]::Fill',
+    '$picture.SizeMode = [System.Windows.Forms.PictureBoxSizeMode]::StretchImage',
+    `$picture.Image = [System.Drawing.Image]::FromFile("${escapedQrPath}")`,
+    '$form.Controls.Add($picture)',
+    '[System.Windows.Forms.Application]::Run($form)',
+  ].join('\n');
+}

package/server/os/win32/process.js

@@ -0,0 +1,20 @@
+import {spawn} from 'node:child_process';
+import {execFileAsync} from '../../utils/process.js';
+
+export async function commandExistsWin32(command) {
+  const result = await execFileAsync('powershell', [
+    '-NoProfile',
+    '-Command',
+    `if (Get-Command "${command}" -ErrorAction SilentlyContinue) { "true" }`,
+  ]);
+
+  return result.ok && result.stdout.trim() === 'true';
+}
+
+export function spawnPowerShellFile(scriptPath) {
+  return spawn(
+    'powershell',
+    ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath],
+    {stdio: 'ignore'},
+  );
+}