@velor/remote-mouse 6.4.8

package/server/remotes/vlc/registrar.js

@@ -0,0 +1,94 @@
+import { createLogger } from '../../application/logger.js';
+import {
+  REMOTE_EVENT_VLC_COMMAND,
+  REMOTE_EVENT_VLC_OPEN,
+  REMOTE_EVENT_VLC_WINDOW_CLOSE,
+  REMOTE_EVENT_VLC_WINDOW_TOGGLE,
+} from '../../../utils/remoteCommands.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('vlc:remote');
+  return log;
+}
+const VLC_ACTIONS = {
+  previous: { key: 'p' },
+  'play-pause': { key: 'space' },
+  next: { key: 'n' },
+  'seek-backward': { key: 'left' },
+  stop: { key: 's' },
+  'seek-forward': { key: 'right' },
+  'volume-down': { key: 'down', modifiers: ['control'] },
+  mute: { key: 'm' },
+  'volume-up': { key: 'up', modifiers: ['control'] },
+  fullscreen: { key: 'f' },
+};
+
+function isVlcEnabled(config) {
+  return config?.vlc?.enabled !== false;
+}
+
+export function createVlcRegistrar({ vlc, keyboard, getConfig = () => ({}) }) {
+  const log = getModuleLog();
+  return (socket) => {
+    const client = socket.id.slice(0, 8);
+
+    async function ensureUsable() {
+      if (!(await vlc.isAvailable())) {
+        log.info({ client }, 'VLC ignore: non disponible sur le host.');
+        return false;
+      }
+      if (!isVlcEnabled(getConfig())) {
+        log.info({ client }, 'VLC ignore: desactive par configuration.');
+        return false;
+      }
+      return true;
+    }
+
+    socket.on(REMOTE_EVENT_VLC_OPEN, async () => {
+      if (!(await ensureUsable())) {
+        return;
+      }
+
+      log.info({ client }, `Demande ${REMOTE_EVENT_VLC_OPEN}`);
+      await vlc.focusOrLaunch();
+    });
+
+    socket.on(REMOTE_EVENT_VLC_COMMAND, async (payload = {}) => {
+      if (!(await ensureUsable())) {
+        return;
+      }
+
+      const action = typeof payload?.action === 'string' ? payload.action : '';
+      const command = VLC_ACTIONS[action];
+      if (!command) {
+        return;
+      }
+
+      log.info({ client, action }, `Demande ${REMOTE_EVENT_VLC_COMMAND}`);
+      const focused = await vlc.focusOrLaunch();
+      if (!focused) {
+        return;
+      }
+      await keyboard.pressSpecialKey(command.key, command.modifiers);
+    });
+
+    socket.on(REMOTE_EVENT_VLC_WINDOW_TOGGLE, async () => {
+      if (!(await ensureUsable())) {
+        return;
+      }
+
+      log.info({ client }, `Demande ${REMOTE_EVENT_VLC_WINDOW_TOGGLE}`);
+      await vlc.toggleWindow();
+    });
+
+    socket.on(REMOTE_EVENT_VLC_WINDOW_CLOSE, async () => {
+      if (!(await ensureUsable())) {
+        return;
+      }
+
+      log.info({ client }, `Demande ${REMOTE_EVENT_VLC_WINDOW_CLOSE}`);
+      await vlc.closeWindow();
+    });
+  };
+}

package/server/remotes/vlc/spec.js

@@ -0,0 +1,15 @@
+export const VLC_APP_SPEC = {
+  linux: {
+    commands: ['vlc'],
+    processNames: ['vlc', 'vlc.bin'],
+    windowClasses: ['vlc'],
+    windowNames: ['vlc', 'vlc media player'],
+  },
+  darwin: {
+    apps: ['VLC', 'VLC media player'],
+  },
+  win32: {
+    commands: ['vlc'],
+    windowTitles: ['VLC media player', 'VLC'],
+  },
+};

package/server/remotes/vlc/state.js

@@ -0,0 +1,5 @@
+export function createVlcReceiverState() {
+  return {
+    inFlight: false,
+  };
+}

package/server/remotes/window/index.js

@@ -0,0 +1,6 @@
+export function createWindowActions(osService) {
+  return {
+    toggleMaximizeMinimize: () => osService.window.toggleActive(),
+    closeActiveWindow: () => osService.window.closeActive(),
+  };
+}

package/server/remotes/window/registrar.js

@@ -0,0 +1,28 @@
+import { createLogger } from '../../application/logger.js';
+import {
+  REMOTE_EVENT_WINDOW_CLOSE,
+  REMOTE_EVENT_WINDOW_TOGGLE_MAXIMIZE,
+} from '../../../utils/remoteCommands.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('window:remote');
+  return log;
+}
+
+export function createWindowRegistrar({ windowActions }) {
+  const log = getModuleLog();
+  return (socket) => {
+    const client = socket.id.slice(0, 8);
+
+    socket.on(REMOTE_EVENT_WINDOW_TOGGLE_MAXIMIZE, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_WINDOW_TOGGLE_MAXIMIZE}`);
+      await windowActions.toggleMaximizeMinimize();
+    });
+
+    socket.on(REMOTE_EVENT_WINDOW_CLOSE, async () => {
+      log.info({ client }, `Demande ${REMOTE_EVENT_WINDOW_CLOSE}`);
+      await windowActions.closeActiveWindow();
+    });
+  };
+}

package/server/services/application/createApplicationDaemonService.js

@@ -0,0 +1,144 @@
+import {writeRestartMarker} from '../../remotes/admin/notifyIfRestarted.js';
+import {getDaemonServiceAdapter} from "./getDaemonServiceAdapter.js";
+import {spawnDetached} from '../../utils/process.js';
+
+async function spawnCustomRestartCommand(command) {
+  const normalizedCommand = String(command || '').trim();
+  if (!normalizedCommand) {
+    return null;
+  }
+
+  const spawned = process.platform === 'win32'
+    ? await spawnDetached('powershell', ['-NoProfile', '-Command', normalizedCommand])
+    : await spawnDetached('bash', ['-lc', normalizedCommand]);
+
+  if (!spawned) {
+    return {
+      ok: false,
+      message: 'Impossible de lancer la commande custom de redemarrage.',
+      details: {message: 'spawn custom restart command failed'},
+    };
+  }
+
+  return {
+    ok: true,
+    message: 'Commande custom de redemarrage lancee.',
+  };
+}
+
+export function createApplicationDaemonService(services) {
+  return {
+    async install() {
+      const systemConfig = services.getSystemConfig();
+      const serviceName = String(systemConfig.serviceName || '').trim();
+      const adapter = getDaemonServiceAdapter();
+
+      if (!serviceName) {
+        return {ok: false, message: 'serviceName non configure.'};
+      }
+
+      if (adapter.install) {
+        return adapter.install(serviceName);
+      }
+
+      return {ok: false, message: `Plateforme non supportee pour le daemon: ${process.platform}`};
+    },
+
+    async disable() {
+      const systemConfig = services.getSystemConfig();
+      const serviceName = String(systemConfig.serviceName || '').trim();
+      const adapter = getDaemonServiceAdapter();
+
+      if (!serviceName) {
+        return {ok: false, message: 'serviceName non configure.'};
+      }
+
+      if (adapter.disable) {
+        return adapter.disable(serviceName);
+      }
+
+      return {ok: false, message: `Plateforme non supportee pour la desactivation du daemon: ${process.platform}`};
+    },
+
+    async uninstall() {
+      const systemConfig = services.getSystemConfig();
+      const serviceName = String(systemConfig.serviceName || '').trim();
+      const adapter = getDaemonServiceAdapter();
+
+      if (!serviceName) {
+        return {ok: false, message: 'serviceName non configure.'};
+      }
+
+      if (adapter.uninstall) {
+        return adapter.uninstall(serviceName);
+      }
+
+      return {ok: false, message: `Plateforme non supportee pour la desinstallation du daemon: ${process.platform}`};
+    },
+
+    async restart({cause = 'user', source = 'unknown'} = {}) {
+      const systemConfig = services.getSystemConfig();
+      const serviceName = String(systemConfig.serviceName || '').trim();
+      const restartCommand = String(systemConfig.serviceRestartCommand || '').trim();
+      const adapter = getDaemonServiceAdapter();
+      const restartLogDao = services.getPersistence().restartLogDao;
+      const restartId = restartLogDao.createRestartRequest({
+        cause,
+        source,
+        details: {
+          serviceName,
+          restartCommand,
+          platformKind: adapter.platformKind,
+        },
+      });
+
+      writeRestartMarker({
+        restartId,
+        cause,
+        source,
+      });
+
+      if (restartCommand) {
+        const result = await spawnCustomRestartCommand(restartCommand);
+        if (!result?.ok) {
+          restartLogDao.updateRestartStatus(restartId, {
+            status: 'failed',
+            details: result?.details || {message: 'custom restart failed'},
+          });
+          return result;
+        }
+
+        return {
+          ...result,
+          restartId,
+        };
+      }
+
+      if (!adapter.restart) {
+        restartLogDao.updateRestartStatus(restartId, {
+          status: 'failed',
+          details: {message: `unsupported platform ${process.platform}`},
+        });
+        return {ok: false, message: `Plateforme non supportee pour le redemarrage: ${process.platform}`};
+      }
+
+      const result = await adapter.restart(serviceName);
+      if (!result?.ok) {
+        restartLogDao.updateRestartStatus(restartId, {
+          status: 'failed',
+          details: result?.details || {message: 'restart failed'},
+        });
+        return result;
+      }
+
+      return {
+        ...result,
+        restartId,
+      };
+    },
+
+    getInfo() {
+      return getDaemonServiceAdapter().getInfo(String(services.getSystemConfig().serviceName || '').trim());
+    },
+  };
+}

package/server/services/application/getDaemonServiceAdapter.js

@@ -0,0 +1,56 @@
+import {getPlatformKind} from "./utils.js";
+import {
+    disableLinuxDaemon,
+    getLinuxDaemonInfo,
+    installLinuxDaemon,
+    uninstallLinuxDaemon,
+    restartLinuxDaemon
+} from "../../os/linux/systemd.js";
+import {
+    disableWindowsDaemon,
+    getWindowsDaemonInfo,
+    installWindowsDaemon,
+    uninstallWindowsDaemon,
+    restartWindowsDaemon
+} from "../../os/win32/service.js";
+
+export function getDaemonServiceAdapter() {
+    const platformKind = getPlatformKind();
+
+    if (platformKind === 'systemd-user') {
+        return {
+            platformKind,
+            install: installLinuxDaemon,
+            disable: disableLinuxDaemon,
+            uninstall: uninstallLinuxDaemon,
+            restart: restartLinuxDaemon,
+            getInfo: getLinuxDaemonInfo,
+        };
+    }
+
+    if (platformKind === 'windows-scheduled-task') {
+        return {
+            platformKind,
+            install: installWindowsDaemon,
+            disable: disableWindowsDaemon,
+            uninstall: uninstallWindowsDaemon,
+            restart: restartWindowsDaemon,
+            getInfo: getWindowsDaemonInfo,
+        };
+    }
+
+    return {
+        platformKind,
+        install: null,
+        disable: null,
+        uninstall: null,
+        restart: null,
+        getInfo: async (serviceName) => ({
+            serviceName,
+            platform: process.platform,
+            platformKind,
+            runningAsDaemon: false,
+            installed: false,
+        }),
+    };
+}

package/server/services/application/utils.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import {projectRoot} from "../../utils/paths.js";
+import os from "node:os";
+
+export function getPlatformKind() {
+    if (process.platform === 'linux') {
+        return 'systemd-user';
+    }
+    if (process.platform === 'win32') {
+        return 'windows-scheduled-task';
+    }
+    return 'unsupported';
+}
+
+export function isDaemonProcess() {
+    return String(process.env.REMOTE_MOUSE_DAEMON || '').trim() === '1';
+}
+
+export function getEntrypoint() {
+    return path.join(projectRoot, 'bin', 'remote-mouse.js');
+}
+
+export function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+export function getSystemdUnitPath(serviceName) {
+    return path.join(os.homedir(), '.config', 'systemd', 'user', serviceName);
+}

package/server/services/config/bootstrapConfig.js

@@ -0,0 +1,38 @@
+import {
+    loadEnvFile,
+    readString,
+    resolveConfigDir,
+    resolveEnvFilePath
+} from "../../utils/env.js";
+
+import {fileURLToPath} from "node:url";
+import path from "node:path";
+import fs from "node:fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const projectRoot = path.join(__dirname, '../..');
+export const packageJsonPath = path.join(projectRoot, 'package.json');
+
+export const bootstrapConfigDir = resolveConfigDir(process.env.CONFIG_DIR || '');
+
+export const envFilePath = resolveEnvFilePath({
+    appRoot: projectRoot,
+    configDir: bootstrapConfigDir,
+    explicitEnvFilePath: process.env.ENV_FILE_PATH || '',
+});
+
+loadEnvFile(envFilePath);
+
+export const CONFIG_DIR = resolveConfigDir(readString('CONFIG_DIR', bootstrapConfigDir));
+
+export function readPackageJson() {
+    try {
+        const raw = fs.readFileSync(packageJsonPath, 'utf8');
+        return JSON.parse(raw);
+    } catch (_error) {
+        return {};
+    }
+}
+
+export const packageJson = readPackageJson();

package/server/services/config/configPaths.js

@@ -0,0 +1,42 @@
+import { getNotificationPaths } from '../../../utils/notificationSettings.js';
+import { BROWSER_CATALOG } from '../../remotes/browser/browserCatalog.js';
+
+const BROWSER_CONFIG_PATHS = BROWSER_CATALOG.map((browser) => `browser.${browser.id}`);
+
+export const CONFIG_PATHS = [
+    'input.mouseSpeed',
+    'input.scrollSpeed',
+    'input.touchDragHoldMs',
+    'input.touchDragStillDistancePx',
+    'browser.enabled',
+    ...BROWSER_CONFIG_PATHS,
+    'keyboard.enabled',
+    'vlc.enabled',
+    'preview.enabled',
+    'preview.width',
+    'preview.height',
+    'preview.fps',
+    'preview.hideDelayMs',
+    'notifications.ttlMs',
+    ...getNotificationPaths(),
+    'samsungTv.enabled',
+    'samsungTv.alwaysAutoResolve',
+    'samsungTv.host',
+    'samsungTv.mac',
+    'samsungTv.port',
+    'samsungTv.appName',
+    'samsungTv.discoveryTimeoutMs',
+    'samsungTv.timeoutMs',
+    'samsungTv.pcInputKey',
+    'samsungTv.pcInputSequence',
+    'samsungTv.powerOffKey',
+    'updateCheck.enabled',
+    'qrOverlay.enabled',
+    'qrOverlay.size',
+    'qrOverlay.margin',
+    'qrOverlay.topOffsetPx',
+    'qrOverlay.autoHideOnHover',
+    'qrOverlay.hoverEntryMarginPx',
+    'qrOverlay.hoverExitMarginPx',
+    'qrOverlay.hoverShowDelayMs',
+];