@velor/remote-mouse 6.4.8

package/server/services/overlay/createQrOverlay.js

@@ -0,0 +1,27 @@
+import os from 'node:os';
+import {createLogger} from '../../application/logger.js';
+import {createNoopOverlay} from './createNoopOverlay.js';
+import {createQrOverlayYad} from './createQrOverlayYad.js';
+import {createQrOverlayWin32} from './createQrOverlayWin32.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('qr-overlay');
+  return log;
+}
+
+export async function createQrOverlay(services) {
+  const log = getModuleLog();
+  const platform = os.platform();
+
+  if (platform === 'linux') {
+    return createQrOverlayYad(services);
+  }
+
+  if (platform === 'win32') {
+    return createQrOverlayWin32(services);
+  }
+
+  log.info({ platform }, 'QR overlay non supporté sur cette plateforme');
+  return createNoopOverlay();
+}

package/server/services/overlay/createQrOverlayWin32.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import QRCode from 'qrcode';
+import {DEFAULT_PERSISTED_CONFIG} from '../config/defaultConfig.js';
+import {createLogger} from '../../application/logger.js';
+import {createNoopOverlay} from './createNoopOverlay.js';
+import {
+  buildQrOverlayPowerShellScript,
+  spawnPowerShellFile,
+} from '../os/platforms/win32/overlay.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('qr-overlay:win32');
+  return log;
+}
+
+export async function createQrOverlayWin32(services) {
+  const log = getModuleLog();
+  const getUrl = () => services.getUrls().entryUrl;
+  const getConfig = () => services.getConfig();
+  
+  function getOverlayContext() {
+    const config = getConfig?.() || {};
+    const qrOverlayConfig = {
+      ...DEFAULT_PERSISTED_CONFIG.qrOverlay,
+      ...config.qrOverlay,
+    };
+    return {
+      qrOverlayConfig,
+      startsVisible: Boolean(qrOverlayConfig.enabled),
+      isSupported: os.platform() === 'win32',
+    };
+  }
+
+  if (!getOverlayContext().isSupported) {
+    return createNoopOverlay();
+  }
+
+  const qrPath = path.join(os.tmpdir(), 'remote-mouse-qr-overlay.png');
+  const scriptPath = path.join(os.tmpdir(), 'remote-mouse-qr-overlay.ps1');
+  let child = null;
+  let refreshChain = Promise.resolve();
+  let visible = getOverlayContext().startsVisible;
+  let suppressed = false;
+  let overlayBounds = null;
+
+  const close = () => {
+    if (child && !child.killed) {
+      child.kill('SIGTERM');
+    }
+    child = null;
+  };
+
+  async function spawnOverlay() {
+    const {qrOverlayConfig, isSupported} = getOverlayContext();
+    if (!isSupported) {
+      return;
+    }
+
+    const size = qrOverlayConfig.size;
+    const margin = qrOverlayConfig.margin;
+    await QRCode.toFile(qrPath, getUrl(), { width: size, margin: 1 });
+
+    const screen = await services.getSystem().getScreenInfo() || {width: size + margin, height: size + margin};
+    const posX = Math.max(0, screen.width - size - margin);
+    const posY = Math.max(0, margin);
+    overlayBounds = {
+      x: posX,
+      y: posY,
+      width: size,
+      height: size,
+    };
+
+    fs.writeFileSync(
+      scriptPath,
+      buildQrOverlayPowerShellScript({qrPath, size, posX, posY}),
+      'utf8',
+    );
+
+    child = spawnPowerShellFile(scriptPath);
+    child.once('error', (error) => {
+      log.warn({ err: error }, 'Impossible de lancer PowerShell pour QR overlay');
+    });
+    log.debug({ url: getUrl() }, 'QR overlay Windows rafraîchi');
+  }
+
+  const update = async () => {
+    if (!visible || suppressed || !getOverlayContext().isSupported) {
+      return;
+    }
+
+    const previousRefresh = refreshChain;
+    refreshChain = (async () => {
+      try {
+        await previousRefresh;
+        close();
+        await spawnOverlay();
+      } catch (_error) {}
+    })();
+
+    await refreshChain;
+  };
+
+  const hide = () => {
+    visible = false;
+    close();
+    return visible;
+  };
+
+  const show = async () => {
+    if (!getOverlayContext().isSupported) {
+      visible = false;
+      return visible;
+    }
+    visible = true;
+    await update();
+    return visible;
+  };
+
+  const setSuppressed = (nextSuppressed) => {
+    const normalized = Boolean(nextSuppressed);
+    if (suppressed === normalized) {
+      return suppressed;
+    }
+
+    suppressed = normalized;
+    if (suppressed) {
+      close();
+      return suppressed;
+    }
+
+    void update();
+    return suppressed;
+  };
+
+  const toggle = async () => {
+    if (visible) {
+      hide();
+      return visible;
+    }
+    await show();
+    return visible;
+  };
+
+  return {
+    close,
+    show,
+    hide,
+    update,
+    setSuppressed,
+    toggle,
+    isVisible: () => visible,
+    isSuppressed: () => suppressed,
+    getBounds: () => overlayBounds,
+  };
+}

package/server/services/overlay/createQrOverlayYad.js

@@ -0,0 +1,178 @@
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import QRCode from 'qrcode';
+import {DEFAULT_PERSISTED_CONFIG} from '../config/defaultConfig.js';
+import {createLogger} from '../../application/logger.js';
+import {createNoopOverlay} from './createNoopOverlay.js';
+import {commandExists} from '../../os/linux/process.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('qr-overlay:yad');
+  return log;
+}
+
+export function buildQrOverlayYadArgs({qrPath, size, posX, posY}) {
+  return [
+    '--picture',
+    '--class=remote-mouse-qr-overlay',
+    '--undecorated',
+    '--skip-taskbar',
+    '--sticky',
+    '--on-top',
+    '--no-buttons',
+    '--fixed',
+    '--borders=0',
+    `--width=${size}`,
+    `--height=${size}`,
+    `--posx=${posX}`,
+    `--posy=${posY}`,
+    '--size=orig',
+    `--filename=${qrPath}`,
+  ];
+}
+
+export async function createQrOverlayYad(services) {
+  const log = getModuleLog();
+  const getUrl = () => services.getUrls().entryUrl;
+  const getConfig = () => services.getConfig();
+  const getSystemConfig = () => services.getSystemConfig();
+
+  function getOverlayContext() {
+    const config = getConfig?.() || {};
+    const systemConfig = getSystemConfig?.() || {};
+    const qrOverlayConfig = {
+      ...DEFAULT_PERSISTED_CONFIG.qrOverlay,
+      ...config.qrOverlay,
+    };
+
+    return {
+      qrOverlayConfig,
+      startsVisible: Boolean(qrOverlayConfig.enabled),
+      isSupported: os.platform() === 'linux'
+        && Boolean(systemConfig.graphicalDisplay),
+    };
+  }
+
+  if (!getOverlayContext().isSupported) {
+    return createNoopOverlay();
+  }
+
+  const hasYad = await commandExists('yad');
+  if (!hasYad) {
+    log.warn('Overlay QR non lancé: "yad" est introuvable.');
+    return createNoopOverlay();
+  }
+
+  const qrPath = path.join(os.tmpdir(), 'remote-mouse-qr-overlay.png');
+  let child = null;
+  let refreshChain = Promise.resolve();
+  let visible = getOverlayContext().startsVisible;
+  let suppressed = false;
+  let overlayBounds = null;
+
+  const close = () => {
+    if (child && !child.killed) {
+      child.kill('SIGTERM');
+    }
+    child = null;
+  };
+
+  async function spawnOverlay() {
+    const {qrOverlayConfig, isSupported} = getOverlayContext();
+    if (!isSupported) {
+      return;
+    }
+
+    const size = qrOverlayConfig.size;
+    const margin = qrOverlayConfig.margin;
+    const topBarOffset = qrOverlayConfig.topOffsetPx;
+    await QRCode.toFile(qrPath, getUrl(), { width: size, margin: 1 });
+
+    const screen = await services.getSystem().getScreenInfo() || {width: size + margin, height: size + margin};
+    const posX = Math.max(0, screen.width - size - margin);
+    const posY = Math.max(0, margin + topBarOffset);
+    overlayBounds = {
+      x: posX,
+      y: posY,
+      width: size,
+      height: size,
+    };
+
+    const args = buildQrOverlayYadArgs({qrPath, size, posX, posY});
+
+    child = spawn('yad', args, { stdio: 'ignore' });
+    log.debug({ url: getUrl() }, 'QR overlay rafraîchi');
+  }
+
+  const update = async () => {
+    if (!visible || suppressed || !getOverlayContext().isSupported) {
+      return;
+    }
+
+    const previousRefresh = refreshChain;
+    refreshChain = (async () => {
+      try {
+        await previousRefresh;
+        close();
+        await spawnOverlay();
+      } catch (_error) {}
+    })();
+
+    await refreshChain;
+  };
+
+  const hide = () => {
+    visible = false;
+    close();
+    return visible;
+  };
+
+  const show = async () => {
+    if (!getOverlayContext().isSupported) {
+      visible = false;
+      return visible;
+    }
+    visible = true;
+    await update();
+    return visible;
+  };
+
+  const setSuppressed = (nextSuppressed) => {
+    const normalized = Boolean(nextSuppressed);
+    if (suppressed === normalized) {
+      return suppressed;
+    }
+
+    suppressed = normalized;
+    if (suppressed) {
+      close();
+      return suppressed;
+    }
+
+    void update();
+    return suppressed;
+  };
+
+  const toggle = async () => {
+    if (visible) {
+      hide();
+      return visible;
+    }
+    await show();
+    return visible;
+  };
+
+  return {
+    close,
+    show,
+    hide,
+    update,
+    setSuppressed,
+    toggle,
+    isVisible: () => visible,
+    isSuppressed: () => suppressed,
+    getBounds: () => overlayBounds,
+  };
+}

package/server/services/overlay/renderQrPage.js

@@ -0,0 +1,82 @@
+export function renderQrPage({ qrDataUrl, publicUrl }) {
+  return `<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Remote Mouse - QR</title>
+<style>
+  :root {
+    color-scheme: dark;
+    --bg: #101417;
+    --panel: rgba(19, 27, 33, 0.92);
+    --text: #f0f4f7;
+    --muted: rgba(240, 244, 247, 0.8);
+    --line: rgba(255,255,255,.12);
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    min-height: 100vh;
+    display: grid;
+    place-items: center;
+    padding: 20px;
+    font-family: system-ui, sans-serif;
+    background: radial-gradient(circle at 20% 10%, #1f2e3a, var(--bg));
+    color: var(--text);
+  }
+  .card {
+    width: min(100%, 860px);
+    display: grid;
+    grid-template-columns: minmax(220px, 360px) minmax(0, 1fr);
+    gap: 22px;
+    align-items: center;
+    padding: 22px;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: 20px;
+    box-shadow: 0 18px 48px rgba(0,0,0,.35);
+  }
+  .copy h1 { margin: 0 0 10px; font-size: clamp(1.4rem, 4vw, 2rem); }
+  .copy p { margin: 0 0 14px; color: var(--muted); line-height: 1.5; }
+  .qr-wrap {
+    display: grid;
+    place-items: center;
+    padding: 14px;
+    border-radius: 18px;
+    background: rgba(255,255,255,.04);
+  }
+  img { width: min(100%, 320px); height: auto; background: white; padding: 12px; border-radius: 14px; }
+  code {
+    display: block;
+    width: 100%;
+    padding: 12px 14px;
+    border-radius: 12px;
+    background: rgba(255,255,255,.04);
+    color: var(--text);
+    font-size: .92rem;
+    word-break: break-word;
+  }
+  @media (max-width: 720px) {
+    .card {
+      grid-template-columns: 1fr;
+      text-align: center;
+      padding: 18px;
+    }
+  }
+</style>
+</head>
+<body>
+  <div class="card">
+    <div class="qr-wrap">
+      <img src="${qrDataUrl}" alt="QR code" />
+    </div>
+    <div class="copy">
+      <h1>Scanner pour connecter</h1>
+      <p>Ouvrez cette page sur mobile ou scannez le code QR pour acceder directement a la telecommande.</p>
+      <code>${publicUrl}</code>
+    </div>
+  </div>
+</body>
+</html>`;
+}

package/server/services/persistence/createConfigDao.js

@@ -0,0 +1,106 @@
+const CONFIG_TABLE = 'config_entries';
+
+export function createConfigDao({getDatabase} = {}) {
+    let bootstrapped = false;
+
+    function bootstrapConfigDatabase() {
+        const db = getDatabase();
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS ${CONFIG_TABLE}
+            (
+                key TEXT PRIMARY KEY,
+                value_json TEXT NOT NULL
+            )
+        `);
+    }
+
+    function saveOne(key, value) {
+        const db = getDatabase();
+        if (!bootstrapped) {
+            bootstrapConfigDatabase();
+            bootstrapped = true;
+        }
+
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey) {
+            return 0;
+        }
+
+        const statement = db.prepare(`
+            INSERT INTO ${CONFIG_TABLE} (key, value_json)
+            VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json
+        `);
+        return statement.run(normalizedKey, JSON.stringify(value)).changes;
+    }
+
+    function getOne(key) {
+        const db = getDatabase();
+        if (!bootstrapped) {
+            bootstrapConfigDatabase();
+            bootstrapped = true;
+        }
+
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey) {
+            return undefined;
+        }
+
+        const row = db.prepare(`SELECT value_json FROM ${CONFIG_TABLE} WHERE key = ?`).get(normalizedKey);
+        if (!row) {
+            return undefined;
+        }
+
+        try {
+            return JSON.parse(row.value_json);
+        } catch (_error) {
+            return row.value_json;
+        }
+    }
+
+    function getAll() {
+        const db = getDatabase();
+        if (!bootstrapped) {
+            bootstrapConfigDatabase();
+            bootstrapped = true;
+        }
+
+        const rows = db.prepare(`SELECT key, value_json FROM ${CONFIG_TABLE}`).all();
+        return rows.map((row) => {
+            let value;
+            try {
+                value = JSON.parse(row.value_json);
+            } catch (_error) {
+                value = row.value_json;
+            }
+
+            return {
+                key: row.key,
+                value,
+            };
+        });
+    }
+
+    function deleteOne(key) {
+        const db = getDatabase();
+        if (!bootstrapped) {
+            bootstrapConfigDatabase();
+            bootstrapped = true;
+        }
+
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey) {
+            return 0;
+        }
+
+        return db.prepare(`DELETE FROM ${CONFIG_TABLE} WHERE key = ?`).run(normalizedKey).changes;
+    }
+
+    return {
+        bootstrapConfigDatabase,
+        saveOne,
+        getOne,
+        getAll,
+        deleteOne,
+    };
+}

package/server/services/persistence/createDatabaseProvider.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+
+export function createDatabaseProvider({getDatabasePath}) {
+    let database = null;
+
+    return function getDatabase() {
+        const configuredDatabasePath = String(getDatabasePath?.() || '').trim();
+        if (!configuredDatabasePath) {
+            throw new Error('Persistence database path is not configured');
+        }
+
+        if (database) {
+            return database;
+        }
+
+        fs.mkdirSync(path.dirname(configuredDatabasePath), {recursive: true});
+        database = new Database(configuredDatabasePath);
+        database.pragma('journal_mode = WAL');
+        return database;
+    };
+}

package/server/services/persistence/createEntryTokenDao.js

@@ -0,0 +1,140 @@
+const ENTRY_TOKEN_TABLE = 'entry_tokens';
+
+export function createEntryTokenDao({getDatabase}) {
+    let bootstrapped = false;
+
+    function bootstrapEntryTokenTable() {
+        if (bootstrapped) {
+            return;
+        }
+
+        const db = getDatabase();
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS ${ENTRY_TOKEN_TABLE} (
+                token TEXT PRIMARY KEY,
+                created_at INTEGER NOT NULL
+            )
+        `);
+        bootstrapped = true;
+    }
+
+    function loadEntryTokens() {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const rows = db.prepare(`
+            SELECT token, created_at
+            FROM ${ENTRY_TOKEN_TABLE}
+            ORDER BY created_at ASC
+        `).all();
+
+        return new Map(rows.map((row) => [row.token, row.created_at]));
+    }
+
+    function countEntryTokens() {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const row = db.prepare(`
+            SELECT COUNT(*) AS count
+            FROM ${ENTRY_TOKEN_TABLE}
+        `).get();
+
+        return Number(row?.count || 0);
+    }
+
+    function getLatestEntryToken() {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const row = db.prepare(`
+            SELECT token
+            FROM ${ENTRY_TOKEN_TABLE}
+            ORDER BY created_at DESC
+            LIMIT 1
+        `).get();
+
+        return String(row?.token || '');
+    }
+
+    function getLatestEntryTokenRecord() {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const row = db.prepare(`
+            SELECT token, created_at
+            FROM ${ENTRY_TOKEN_TABLE}
+            ORDER BY created_at DESC
+            LIMIT 1
+        `).get();
+
+        if (!row) {
+            return null;
+        }
+
+        return {
+            token: String(row.token || ''),
+            createdAt: Number(row.created_at),
+        };
+    }
+
+    function deleteExpiredEntryTokens({olderThan, keepToken = ''} = {}) {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const safeOlderThan = Math.floor(Number(olderThan));
+        if (!Number.isFinite(safeOlderThan)) {
+            return 0;
+        }
+
+        if (keepToken) {
+            const result = db.prepare(`
+                DELETE FROM ${ENTRY_TOKEN_TABLE}
+                WHERE token != ?
+                  AND created_at < ?
+            `).run(keepToken, safeOlderThan);
+            return result.changes;
+        }
+
+        const result = db.prepare(`
+            DELETE FROM ${ENTRY_TOKEN_TABLE}
+            WHERE created_at < ?
+        `).run(safeOlderThan);
+        return result.changes;
+    }
+
+    function hasEntryToken(token) {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        const row = db.prepare(`
+            SELECT 1
+            FROM ${ENTRY_TOKEN_TABLE}
+            WHERE token = ?
+            LIMIT 1
+        `).get(token);
+
+        return Boolean(row);
+    }
+
+    function createEntryToken(token, createdAt = Date.now()) {
+        bootstrapEntryTokenTable();
+
+        const db = getDatabase();
+        db.prepare(`
+            INSERT INTO ${ENTRY_TOKEN_TABLE} (token, created_at)
+            VALUES (?, ?)
+            ON CONFLICT(token) DO UPDATE SET created_at = excluded.created_at
+        `).run(token, Math.floor(createdAt));
+    }
+
+    return {
+        loadEntryTokens,
+        countEntryTokens,
+        getLatestEntryToken,
+        getLatestEntryTokenRecord,
+        deleteExpiredEntryTokens,
+        hasEntryToken,
+        createEntryToken,
+    };
+}