@velor/remote-mouse 6.4.8

package/server/init/createSocketActionRegistrars.js

@@ -0,0 +1,52 @@
+import {createControlEventRegistrar} from '../remotes/input/registrar.js';
+import {createAdminEventRegistrar} from '../remotes/admin/registrar.js';
+import {createPreviewEventRegistrar} from '../remotes/preview/registrar.js';
+import {createConnectionRegistrar} from '../connection/socket/createConnectionRegistrar.js';
+import {createBrowserRegistrar} from '../remotes/browser/registrar.js';
+import {createSamsungRegistrar} from '../remotes/samsung/registrar.js';
+import {createVlcRegistrar} from '../remotes/vlc/registrar.js';
+import {createWindowRegistrar} from '../remotes/window/registrar.js';
+
+export function createSocketActionRegistrars(services) {
+    return [
+        (socket) => {
+            const {
+                mouse,
+                keyboard,
+                updateConfig,
+            } = services.getInputController();
+            updateConfig();
+            return createControlEventRegistrar({mouse, keyboard})(socket);
+        },
+        (socket) => {
+            const {browser} = services.getRemotes();
+            return createBrowserRegistrar({browser, getConfig: services.getConfig})(socket);
+        },
+        (socket) => {
+            const {adminActions} = services.getRemotes();
+            return createAdminEventRegistrar({adminActions, getSystemConfig: services.getSystemConfig})(socket);
+        },
+        (socket) => {
+            const {preview} = services.getRemotes();
+            return createPreviewEventRegistrar({preview, getConfig: services.getConfig})(socket);
+        },
+        (socket) => {
+            const {samsung} = services.getRemotes();
+            return createSamsungRegistrar({samsung})(socket);
+        },
+        (socket) => {
+            const {vlc} = services.getRemotes();
+            return createVlcRegistrar({
+                vlc,
+                keyboard: services.getInputController().keyboard,
+                getConfig: services.getConfig,
+            })(socket);
+        },
+        (socket) => {
+            const {windowActions} = services.getRemotes();
+            return createWindowRegistrar({windowActions})(socket);
+        },
+        (socket) => createConnectionRegistrar({events: services.getEvents()})(socket)
+    ];
+
+}

package/server/init/observers/startConfigObserver.js

@@ -0,0 +1,51 @@
+import {PUBSUB_SERVICE_CONFIG} from '../../services/pubsub/serviceEventConstants.js';
+import {createLogger} from '../../application/logger.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('config:observer');
+  return log;
+}
+
+function getValueAtPath(source, dottedPath) {
+  return String(dottedPath || '')
+    .split('.')
+    .filter(Boolean)
+    .reduce((cursor, segment) => (cursor == null ? undefined : cursor[segment]), source);
+}
+
+export function startConfigObserver(services) {
+  const log = getModuleLog();
+  const bus = services.getPubSub();
+
+  return bus.subscribe((event) => {
+    const sse = services.getSseService();
+    const config = services.getConfig();
+    const changedKeys = Array.isArray(event.payload?.changedKeys) ? event.payload.changedKeys : [];
+    log.debug({
+      type: event.type,
+      changeType: event.payload?.changeType || '',
+      changedKeys,
+    }, 'Configuration persistante changee');
+    sse.emit({
+      name: 'config.changed',
+      service: event.service,
+      type: event.type,
+      payload: {
+        sequence: event.sequence,
+        at: event.at,
+        type: event.type,
+        changeType: event.payload?.changeType || '',
+        changedKeys,
+        entries: changedKeys.map((path) => ({
+          path,
+          value: getValueAtPath(config, path),
+        })),
+        config,
+        sysConfig: services.getSystemConfig(),
+      },
+    });
+  }, {
+    service: PUBSUB_SERVICE_CONFIG,
+  });
+}

package/server/init/observers/startDisplaySizeObserver.js

@@ -0,0 +1,55 @@
+const DEFAULT_DISPLAY_SIZE_POLL_MS = 1000;
+
+function hasDisplaySizeChanged(previous, next) {
+    return Boolean(previous && next && (previous.width !== next.width || previous.height !== next.height));
+}
+
+export function startDisplaySizeObserver(services, options = {}) {
+    const intervalMs = Math.max(250, Number(options.intervalMs) || DEFAULT_DISPLAY_SIZE_POLL_MS);
+    const getScreenInfo = options.getScreenInfo || (() => services.getSystem?.()?.getScreenInfo?.() || null);
+    let previousSize = null;
+    let polling = false;
+
+    async function poll() {
+        if (polling) {
+            return;
+        }
+
+        let nextSize = null;
+        try {
+            polling = true;
+            nextSize = await getScreenInfo();
+        } finally {
+            polling = false;
+        }
+        if (!nextSize) {
+            return;
+        }
+
+        const mouse = services.getInputController?.().mouse;
+        if (!previousSize) {
+            previousSize = nextSize;
+            mouse?.setScreenSizeOverride?.(nextSize);
+            return;
+        }
+
+        if (!hasDisplaySizeChanged(previousSize, nextSize)) {
+            mouse?.setScreenSizeOverride?.(nextSize);
+            return;
+        }
+
+        const changedFrom = previousSize;
+        previousSize = nextSize;
+        mouse?.remapToScreenSize?.(changedFrom, nextSize);
+        void services.getQrOverlay?.()?.update?.();
+    }
+
+    void poll();
+    const interval = setInterval(() => {
+        void poll();
+    }, intervalMs);
+
+    interval.unref?.();
+
+    return () => clearInterval(interval);
+}

package/server/init/observers/startNotificationObserver.js

@@ -0,0 +1,49 @@
+import {handleSocketEvent} from "../../services/notifier/mapper/handleSocketEvent.js";
+import {handleUpdateManagerEvent} from "../../services/notifier/mapper/handleUpdateManagerEvent.js";
+import {handleForceUpdateCheckEvent} from "../../services/notifier/mapper/handleForceUpdateCheckEvent.js";
+import {handleInstallUpdateEvent} from "../../services/notifier/mapper/handleInstallUpdateEvent.js";
+import {handleOpenQrBrowserEvent} from "../../services/notifier/handleOpenQrBrowserEvent.js";
+import {handleOpenServerInfoBrowserEvent} from "../../services/notifier/handleOpenServerInfoBrowserEvent.js";
+import {handleRestartServiceEvent} from "../../services/notifier/handleRestartServiceEvent.js";
+import {handleToggleQrOverlayEvent} from "../../services/notifier/handleToggleQrOverlayEvent.js";
+import {handleRotateEntryTokenEvent} from "../../services/notifier/handleRotateEntryTokenEvent.js";
+import {handleSessionEvent} from "../../services/notifier/handleSessionEvent.js";
+import {
+  PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK,
+  PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE,
+  PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER,
+  PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER,
+  PUBSUB_SERVICE_ADMIN_RESTART_SERVICE,
+  PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN,
+  PUBSUB_SERVICE_ADMIN_TOGGLE_QR_OVERLAY,
+  PUBSUB_SERVICE_SESSION,
+  PUBSUB_SERVICE_SOCKET,
+  PUBSUB_SERVICE_UPDATE_MANAGER,
+} from "../../services/pubsub/serviceEventConstants.js";
+
+const NOTIFICATION_HANDLERS = {
+  [PUBSUB_SERVICE_SOCKET]: handleSocketEvent,
+  [PUBSUB_SERVICE_UPDATE_MANAGER]: handleUpdateManagerEvent,
+  [PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK]: handleForceUpdateCheckEvent,
+  [PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE]: handleInstallUpdateEvent,
+  [PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER]: handleOpenQrBrowserEvent,
+  [PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER]: handleOpenServerInfoBrowserEvent,
+  [PUBSUB_SERVICE_ADMIN_RESTART_SERVICE]: handleRestartServiceEvent,
+  [PUBSUB_SERVICE_ADMIN_TOGGLE_QR_OVERLAY]: handleToggleQrOverlayEvent,
+  [PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN]: handleRotateEntryTokenEvent,
+  [PUBSUB_SERVICE_SESSION]: handleSessionEvent,
+};
+
+export function startNotificationObserver(services) {
+  const bus = services.getPubSub();
+  const notifier = services.getNotifier();
+
+  return bus.subscribe((event) => {
+    const handleEvent = NOTIFICATION_HANDLERS[event.service];
+    if (!handleEvent) {
+      return;
+    }
+
+    handleEvent(notifier, event);
+  }, (event) => Boolean(event?.service && event?.type));
+}

package/server/init/observers/startQrOverlayHoverObserver.js

@@ -0,0 +1,89 @@
+function expandBounds(bounds, marginPx) {
+  return {
+    x: bounds.x - marginPx,
+    y: bounds.y - marginPx,
+    width: bounds.width + (marginPx * 2),
+    height: bounds.height + (marginPx * 2),
+  };
+}
+
+function shrinkBounds(bounds, marginPx) {
+  const width = Math.max(1, bounds.width - (marginPx * 2));
+  const height = Math.max(1, bounds.height - (marginPx * 2));
+  return {
+    x: bounds.x + marginPx,
+    y: bounds.y + marginPx,
+    width,
+    height,
+  };
+}
+
+function isPointInsideBounds(point, bounds) {
+  if (!point || !bounds) {
+    return false;
+  }
+
+  return point.x >= bounds.x
+    && point.x <= (bounds.x + bounds.width)
+    && point.y >= bounds.y
+    && point.y <= (bounds.y + bounds.height);
+}
+
+export function startQrOverlayHoverObserver(services) {
+  const robot = services.getRobot();
+  const qrOverlay = services.getQrOverlay();
+  let suppressedAt = 0;
+
+  if (!robot?.getMousePos || !qrOverlay?.getBounds || !qrOverlay?.setSuppressed) {
+    return () => {};
+  }
+
+  const timer = setInterval(() => {
+    const overlayConfig = services.getConfig()?.qrOverlay || {};
+    if (!overlayConfig.autoHideOnHover) {
+      qrOverlay.setSuppressed(false);
+      return;
+    }
+
+    if (!qrOverlay.isVisible?.()) {
+      qrOverlay.setSuppressed(false);
+      return;
+    }
+
+    const bounds = qrOverlay.getBounds();
+    if (!bounds) {
+      qrOverlay.setSuppressed(false);
+      return;
+    }
+
+    const cursor = robot.getMousePos();
+    const entryMarginPx = Math.max(0, Number(overlayConfig.hoverEntryMarginPx) || 10);
+    const exitMarginPx = Math.max(0, Number(overlayConfig.hoverExitMarginPx) || 18);
+    const showDelayMs = Math.max(0, Number(overlayConfig.hoverShowDelayMs) || 1200);
+    const isSuppressed = qrOverlay.isSuppressed?.();
+
+    let nextSuppressed = false;
+    if (isSuppressed) {
+      const stillInsideExitZone = isPointInsideBounds(cursor, expandBounds(bounds, exitMarginPx));
+      const delayElapsed = (Date.now() - suppressedAt) >= showDelayMs;
+      nextSuppressed = stillInsideExitZone || !delayElapsed;
+    } else {
+      nextSuppressed = isPointInsideBounds(cursor, shrinkBounds(bounds, entryMarginPx));
+    }
+
+    if (nextSuppressed && !isSuppressed) {
+      suppressedAt = Date.now();
+    }
+
+    if (!nextSuppressed) {
+      suppressedAt = 0;
+    }
+
+    qrOverlay.setSuppressed(nextSuppressed);
+  }, 80);
+
+  return () => {
+    clearInterval(timer);
+    qrOverlay.setSuppressed(false);
+  };
+}

package/server/init/observers/startQrOverlayRefreshObserver.js

@@ -0,0 +1,53 @@
+import {
+    PUBSUB_EVENT_CONFIG_DELETED,
+    PUBSUB_EVENT_CONFIG_UPDATED,
+    PUBSUB_EVENT_TOKEN_CHANGED,
+    PUBSUB_SERVICE_CONFIG,
+    PUBSUB_SERVICE_TOKEN_MANAGER
+} from "../../services/pubsub/serviceEventConstants.js";
+
+function isQrOverlayConfigEvent(event) {
+    if (event?.type !== PUBSUB_EVENT_CONFIG_UPDATED && event?.type !== PUBSUB_EVENT_CONFIG_DELETED) {
+        return false;
+    }
+
+    const changedKeys = Array.isArray(event?.payload?.changedKeys) ? event.payload.changedKeys : [];
+    return changedKeys.some((key) => String(key || '').startsWith('qrOverlay.'));
+}
+
+function isQrOverlayRefreshEvent(event) {
+    if (event?.service === PUBSUB_SERVICE_TOKEN_MANAGER && event?.type === PUBSUB_EVENT_TOKEN_CHANGED) {
+        return true;
+    }
+
+    return event?.service === PUBSUB_SERVICE_CONFIG && isQrOverlayConfigEvent(event);
+}
+
+export function startQrOverlayRefreshObserver(services) {
+    const bus = services.getPubSub();
+    const qrOverlay = services.getQrOverlay();
+
+    return bus.subscribe((event) => {
+        if (event.service === PUBSUB_SERVICE_TOKEN_MANAGER) {
+            void qrOverlay.update();
+            return;
+        }
+
+        if (!isQrOverlayConfigEvent(event)) {
+            return;
+        }
+
+        const changedKeys = Array.isArray(event?.payload?.changedKeys) ? event.payload.changedKeys : [];
+        if (changedKeys.includes('qrOverlay.enabled')) {
+            if (services.getConfig().qrOverlay?.enabled) {
+                void qrOverlay.show?.();
+                return;
+            }
+
+            qrOverlay.hide?.();
+            return;
+        }
+
+        void qrOverlay.update();
+    }, isQrOverlayRefreshEvent);
+}

package/server/os/darwin/app.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import {execFileAsync} from '../../utils/process.js';
+import {buildAppWindowScript} from './applescript.js';
+
+export function findInstalledDarwinApp(apps = []) {
+  for (const appName of apps) {
+    const locations = [
+      `/Applications/${appName}.app`,
+      `/System/Applications/${appName}.app`,
+    ];
+    if (locations.some((path) => fs.existsSync(path))) {
+      return appName;
+    }
+  }
+  return '';
+}
+
+export async function resolveDarwinApp(spec = {}) {
+  const appName = findInstalledDarwinApp(spec.darwin?.apps ?? []);
+  return appName ? {appName} : null;
+}
+
+export async function openOrFocusDarwinApp(spec) {
+  const resolved = await resolveDarwinApp(spec);
+  if (!resolved) {
+    return false;
+  }
+  return (await execFileAsync('open', ['-a', resolved.appName])).ok;
+}
+
+export async function toggleDarwinAppWindow(spec) {
+  const resolved = await resolveDarwinApp(spec);
+  if (!resolved) {
+    return false;
+  }
+  return (await execFileAsync('osascript', ['-e', buildAppWindowScript(resolved.appName, 'toggle')])).ok;
+}
+
+export async function closeDarwinAppWindow(spec) {
+  const resolved = await resolveDarwinApp(spec);
+  if (!resolved) {
+    return false;
+  }
+  return (await execFileAsync('osascript', ['-e', buildAppWindowScript(resolved.appName, 'close')])).ok;
+}

package/server/os/darwin/applescript.js

@@ -0,0 +1,51 @@
+export function buildAppWindowScript(appName, mode) {
+  if (mode === 'toggle') {
+    return `
+tell application "${appName}" to activate
+tell application "System Events"
+  tell process "${appName}"
+    if (count of windows) is 0 then return false
+    set frontWindow to first window
+    click (first button of frontWindow whose subrole is "AXZoomButton")
+  end tell
+end tell
+return true
+`.trim();
+  }
+
+  return `
+tell application "${appName}" to activate
+tell application "System Events"
+  tell process "${appName}"
+    if (count of windows) is 0 then return false
+    click (first button of first window whose subrole is "AXCloseButton")
+  end tell
+end tell
+return true
+`.trim();
+}
+
+export function buildActiveWindowScript(mode) {
+  if (mode === 'toggle') {
+    return `
+tell application "System Events"
+  tell (first application process whose frontmost is true)
+    if (count of windows) is 0 then return false
+    set frontWindow to first window
+    click (first button of frontWindow whose subrole is "AXZoomButton")
+  end tell
+end tell
+return true
+`.trim();
+  }
+
+  return `
+tell application "System Events"
+  tell (first application process whose frontmost is true)
+    if (count of windows) is 0 then return false
+    click (first button of first window whose subrole is "AXCloseButton")
+  end tell
+end tell
+return true
+`.trim();
+}

package/server/os/darwin/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/darwin/url.js

@@ -0,0 +1,9 @@
+import {execFileAsync} from '../../utils/process.js';
+
+export async function openDarwinUrl(url) {
+  const safeUrl = String(url || '').trim();
+  if (!safeUrl) {
+    return false;
+  }
+  return (await execFileAsync('open', [safeUrl])).ok;
+}

package/server/os/darwin/window.js

@@ -0,0 +1,10 @@
+import {execFileAsync} from '../../utils/process.js';
+import {buildActiveWindowScript} from './applescript.js';
+
+export async function toggleDarwinActiveWindow() {
+  return (await execFileAsync('osascript', ['-e', buildActiveWindowScript('toggle')])).ok;
+}
+
+export async function closeDarwinActiveWindow() {
+  return (await execFileAsync('osascript', ['-e', buildActiveWindowScript('close')])).ok;
+}

package/server/os/linux/app.js

@@ -0,0 +1,120 @@
+import {execFileAsync, spawnDetached} from '../../utils/process.js';
+import {activateWindow, closeWindow, findWindows, toggleWindow} from './windows.js';
+import {resolveLinuxCommand} from './process.js';
+import {sleep} from "../../../utils/sync.js";
+
+export async function isAnyProcessRunning(processNames = []) {
+  const checks = [];
+
+  for (const processName of processNames) {
+    checks.push(await execFileAsync('pgrep', ['-x', processName]));
+    checks.push(await execFileAsync('pgrep', ['-f', processName]));
+  }
+
+  return checks.some((result) => result.ok);
+}
+
+export async function resolveLinuxApp(spec = {}) {
+  const linux = spec.linux || {};
+  let launchCommand = '';
+
+  for (const command of linux.commands || []) {
+    launchCommand = await resolveLinuxCommand(command);
+    if (launchCommand) {
+      break;
+    }
+  }
+
+  if (launchCommand) {
+    return {
+      launchCommand,
+      launchArgs: [],
+      processNames: linux.processNames ?? linux.commands ?? [],
+      windowQuery: {
+        classes: linux.windowClasses ?? [],
+        names: linux.windowNames ?? [],
+      },
+    };
+  }
+
+  const flatpakCommand = linux.flatpakAppId ? await resolveLinuxCommand('flatpak') : '';
+  if (linux.flatpakAppId && flatpakCommand) {
+    return {
+      launchCommand: flatpakCommand,
+      launchArgs: ['run', linux.flatpakAppId],
+      processNames: linux.processNames ?? [],
+      windowQuery: {
+        classes: linux.windowClasses ?? [],
+        names: linux.windowNames ?? [],
+      },
+    };
+  }
+
+  return null;
+}
+
+export async function openOrFocusLinuxApp(spec, {maximize = false} = {}) {
+  const resolved = await resolveLinuxApp(spec);
+  if (!resolved) {
+    return false;
+  }
+
+  const windowIds = await findWindows(resolved.windowQuery);
+  if (windowIds.length > 0) {
+    return activateWindow(windowIds[0], {maximize});
+  }
+
+  const running = await isAnyProcessRunning(resolved.processNames);
+  if (running) {
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const ids = await findWindows(resolved.windowQuery);
+      if (ids.length > 0) {
+        return activateWindow(ids[0], {maximize});
+      }
+      await sleep(250);
+    }
+  }
+
+  const launched = await spawnDetached(resolved.launchCommand, resolved.launchArgs);
+  if (!launched) {
+    return false;
+  }
+
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    const ids = await findWindows(resolved.windowQuery);
+    if (ids.length > 0) {
+      return activateWindow(ids[0], {maximize});
+    }
+    await sleep(350);
+  }
+
+  return true;
+}
+
+export async function toggleLinuxAppWindow(spec) {
+  const resolved = await resolveLinuxApp(spec);
+  if (!resolved) {
+    return false;
+  }
+
+  const ids = await findWindows(resolved.windowQuery);
+  if (ids.length === 0) {
+    return openOrFocusLinuxApp(spec, {maximize: true});
+  }
+
+  return toggleWindow(ids[0]);
+}
+
+export async function closeLinuxAppWindow(spec) {
+  const resolved = await resolveLinuxApp(spec);
+  if (!resolved) {
+    return false;
+  }
+
+  const ids = await findWindows(resolved.windowQuery);
+  if (ids.length === 0) {
+    return false;
+  }
+
+  return closeWindow(ids[0]);
+}