@velor/remote-mouse 6.4.8

package/server/remotes/samsung/createSamsungCommandService.js

@@ -0,0 +1,203 @@
+import {Keys} from "samsung-tv-remote";
+
+import {
+    createSamsungResult,
+    resolveConfiguredKey,
+    resolveConfiguredKeysSequence,
+    toSamsungErrorMessage,
+} from "./utils.js";
+
+export function createSamsungCommandService({getConfig, discoverDevices, getSamsungTv, getLogger, createDisabledRemote}) {
+    let powerStateCache = {
+        value: 'unknown',
+        checkedAt: 0,
+    };
+    let powerStatePromise = null;
+
+    function getEnabledRemote() {
+        if (getConfig().enabled) {
+            return null;
+        }
+        return createDisabledRemote?.();
+    }
+
+    function invalidatePowerState() {
+        powerStateCache = {
+            value: 'unknown',
+            checkedAt: 0,
+        };
+    }
+
+    async function computePowerState() {
+        const disabledRemote = getEnabledRemote();
+        if (disabledRemote) {
+            return 'disabled';
+        }
+
+        try {
+            const samsungTv = await getSamsungTv();
+            return samsungTv.getPowerState();
+        } catch (error) {
+            getLogger().warn({err: error?.message || String(error)}, 'Etat Samsung indisponible');
+            return 'unknown';
+        }
+    }
+
+    async function getPowerState(options = {}) {
+        const maxAgeMs = Number(options.maxAgeMs);
+        const now = Date.now();
+        if (Number.isFinite(maxAgeMs) && maxAgeMs >= 0 && (now - powerStateCache.checkedAt) <= maxAgeMs) {
+            return powerStateCache.value;
+        }
+
+        if (!powerStatePromise) {
+            powerStatePromise = (async () => {
+                try {
+                    const value = await computePowerState();
+                    powerStateCache = {
+                        value,
+                        checkedAt: Date.now(),
+                    };
+                    return value;
+                } finally {
+                    powerStatePromise = null;
+                }
+            })();
+        }
+
+        return powerStatePromise;
+    }
+
+    async function sendKey(key, successMessage) {
+        const disabledRemote = getEnabledRemote();
+        if (disabledRemote) {
+            return disabledRemote.turnOn();
+        }
+        try {
+            const samsungTv = await getSamsungTv();
+            await samsungTv.sendKey(key);
+            invalidatePowerState();
+            getLogger().info({key}, 'Commande Samsung envoyee');
+            return createSamsungResult(successMessage);
+        } catch (error) {
+            const message = toSamsungErrorMessage(error);
+            getLogger().warn({key, err: message}, 'Echec commande Samsung');
+            return {
+                ok: false,
+                message: `TV Samsung indisponible: ${message}`,
+            };
+        }
+    }
+
+    async function sendKeys(keys, successMessage) {
+        const disabledRemote = getEnabledRemote();
+        if (disabledRemote) {
+            return disabledRemote.turnOn();
+        }
+        try {
+            const samsungTv = await getSamsungTv();
+            await samsungTv.sendKeys(keys);
+            invalidatePowerState();
+            getLogger().info({keys}, 'Sequence Samsung envoyee');
+            return createSamsungResult(successMessage);
+        } catch (error) {
+            const message = toSamsungErrorMessage(error);
+            getLogger().warn({keys, err: message}, 'Echec sequence Samsung');
+            return {
+                ok: false,
+                message: `TV Samsung indisponible: ${message}`,
+            };
+        }
+    }
+
+    return {
+        isEnabled() {
+            return Boolean(getConfig().enabled);
+        },
+        async getPowerState(options) {
+            return getPowerState(options);
+        },
+        async discoverDevices() {
+            return discoverDevices();
+        },
+        async turnOn() {
+            const disabledRemote = getEnabledRemote();
+            if (disabledRemote) {
+                return disabledRemote.turnOn();
+            }
+            try {
+                const samsungTv = await getSamsungTv();
+                await samsungTv.wakeTV();
+                invalidatePowerState();
+                getLogger().info('Wake-on-LAN Samsung envoye');
+                return createSamsungResult("Demande d'allumage envoyee a la TV Samsung.");
+            } catch (error) {
+                const message = toSamsungErrorMessage(error);
+                getLogger().warn({err: message}, 'Echec allumage Samsung');
+                return {
+                    ok: false,
+                    message: `Impossible d'allumer la TV Samsung: ${message}`,
+                };
+            }
+        },
+        async turnOff() {
+            const disabledRemote = getEnabledRemote();
+            if (disabledRemote) {
+                return disabledRemote.turnOff();
+            }
+            const config = getConfig();
+            const powerOffKey = resolveConfiguredKey(config.powerOffKey);
+            if (!powerOffKey) {
+                return {
+                    ok: false,
+                    message: `Touche Samsung invalide pour l'extinction: ${config.powerOffKey}`,
+                };
+            }
+            return sendKey(powerOffKey, "Demande d'extinction envoyee a la TV Samsung.");
+        },
+        async volumeUp() {
+            return sendKey(Keys.KEY_VOLUP, 'Volume Samsung augmente.');
+        },
+        async volumeDown() {
+            return sendKey(Keys.KEY_VOLDOWN, 'Volume Samsung diminue.');
+        },
+        async mute() {
+            return sendKey(Keys.KEY_MUTE, 'Mute Samsung active/desactive.');
+        },
+        async switchInput() {
+            return sendKey(Keys.KEY_SOURCE, 'Changement de source Samsung demande.');
+        },
+        async confirm() {
+            return sendKey(Keys.KEY_ENTER, 'Validation Samsung envoyee.');
+        },
+        async switchToPcInput() {
+            const disabledRemote = getEnabledRemote();
+            if (disabledRemote) {
+                return disabledRemote.switchToPcInput();
+            }
+            const config = getConfig();
+            const configuredSequence = resolveConfiguredKeysSequence(config.pcInputSequence);
+            if (configuredSequence.length) {
+                if (configuredSequence.some((key) => !key)) {
+                    return {
+                        ok: false,
+                        message: `Sequence Samsung invalide pour l'entree PC: ${config.pcInputSequence}`,
+                    };
+                }
+                return sendKeys(
+                    configuredSequence,
+                    `Bascule Samsung vers l'entree PC via sequence ${config.pcInputSequence}.`,
+                );
+            }
+
+            const configuredKey = resolveConfiguredKey(config.pcInputKey);
+            if (!configuredKey) {
+                return {
+                    ok: false,
+                    message: `Touche Samsung invalide pour l'entree PC: ${config.pcInputKey}`,
+                };
+            }
+            return sendKey(configuredKey, `Bascule Samsung vers ${config.pcInputKey}.`);
+        },
+    };
+}

package/server/remotes/samsung/createSamsungRemote.js

@@ -0,0 +1,26 @@
+import {createSamsungCommandService} from './createSamsungCommandService.js';
+import {createSamsungDeviceConfigResolver, discoverSamsungDevices} from './device-config.js';
+import {createSamsungTvGetter} from './createSamsungTvGetter.js';
+import {createDisabledSamsungRemote} from './utils.js';
+import {createLogger} from '../../application/logger.js';
+
+let log;
+function getModuleLog() {
+    log ??= createLogger('samsung:remote');
+    return log;
+}
+
+export function createSamsungRemote(services) {
+    const getLogger = () => getModuleLog();
+    const getConfig = ()=> services.getConfig().samsungTv;
+    const resolveDeviceConfig = createSamsungDeviceConfigResolver({getConfig, getLogger});
+    const discoverDevices = discoverSamsungDevices({getConfig});
+    const getSamsungTv = createSamsungTvGetter({getConfig, resolveDeviceConfig});
+    return createSamsungCommandService({
+        getConfig,
+        discoverDevices,
+        getSamsungTv,
+        getLogger,
+        createDisabledRemote: () => createDisabledSamsungRemote('Controle Samsung desactive. Activez SAMSUNG_TV_ENABLED.'),
+    });
+}

package/server/remotes/samsung/createSamsungRemoteGetter.js

@@ -0,0 +1,46 @@
+import {SamsungTvRemote} from "samsung-tv-remote";
+
+export function createSamsungRemoteGetter({
+                                              getConfig,
+                                              resolveDeviceConfig,
+                                              SamsungTvRemoteClass = SamsungTvRemote,
+                                          }) {
+    let remotePromise = null;
+    let remoteKey = '';
+
+    return async function getRemote() {
+        const config = getConfig();
+        const nextKey = JSON.stringify({
+            alwaysAutoResolve: config.alwaysAutoResolve,
+            appName: config.appName,
+            host: config.host,
+            mac: config.mac,
+            port: config.port,
+            timeoutMs: config.timeoutMs,
+        });
+
+        if (!remotePromise || remoteKey !== nextKey) {
+            remoteKey = nextKey;
+            remotePromise = (async () => {
+                try {
+                    const device = await resolveDeviceConfig();
+                    return new SamsungTvRemoteClass({
+                    device: {
+                        ip: device.ip,
+                        mac: device.mac,
+                    },
+                    port: config.port,
+                    name: config.appName,
+                    timeout: config.timeoutMs,
+                    });
+                } catch (error) {
+                    remotePromise = null;
+                    remoteKey = '';
+                    throw error;
+                }
+            })();
+        }
+
+        return remotePromise;
+    };
+}

package/server/remotes/samsung/createSamsungTvGetter.js

@@ -0,0 +1,102 @@
+import { SamsungTvRemote } from 'samsung-tv-remote';
+import { pingHost } from '../../utils/network.js';
+
+function isNoAwakeTvError(error) {
+  return String(error?.message || error || '').includes('aucune TV Samsung reveillee');
+}
+
+function isAmbiguousTvError(error) {
+  return String(error?.message || error || '').includes('plusieurs TV Samsung detectees');
+}
+
+export function createSamsungTvGetter({
+  getConfig,
+  resolveDeviceConfig,
+  pingHostFn = pingHost,
+  SamsungTvRemoteClass = SamsungTvRemote,
+}) {
+  let tvPromise = null;
+  let tvKey = '';
+
+  return async function getSamsungTv() {
+    const config = getConfig();
+    const nextKey = JSON.stringify({
+      alwaysAutoResolve: config.alwaysAutoResolve,
+      appName: config.appName,
+      host: config.host,
+      mac: config.mac,
+      port: config.port,
+      timeoutMs: config.timeoutMs,
+    });
+
+    if (!tvPromise || tvKey !== nextKey) {
+      tvKey = nextKey;
+      tvPromise = (async () => {
+        try {
+          const device = await resolveDeviceConfig();
+          const remote = new SamsungTvRemoteClass({
+            device: {
+              ip: device.ip,
+              mac: device.mac,
+            },
+            port: config.port,
+            name: config.appName,
+            timeout: config.timeoutMs,
+          });
+
+          return {
+            device,
+            remote,
+            async getPowerState() {
+              if (!device?.ip) {
+                return 'unknown';
+              }
+              const reachable = await pingHostFn(
+                device.ip,
+                Math.max(500, Number(config.timeoutMs) || 2000),
+              );
+              return reachable ? 'on' : 'off';
+            },
+            async sendKey(key) {
+              await remote.sendKey(key);
+            },
+            async sendKeys(keys) {
+              await remote.sendKeys(keys);
+            },
+            async wakeTV() {
+              await remote.wakeTV();
+            },
+          };
+        } catch (error) {
+          tvPromise = null;
+          tvKey = '';
+
+          return {
+            device: null,
+            remote: null,
+            async getPowerState() {
+              if (isNoAwakeTvError(error)) {
+                return 'off';
+              }
+              if (isAmbiguousTvError(error)) {
+                return 'unknown';
+              }
+              return 'unknown';
+            },
+            async sendKey() {
+              throw error;
+            },
+            async sendKeys() {
+              throw error;
+            },
+            async wakeTV() {
+              throw error;
+            },
+          };
+        }
+      })();
+    }
+
+    return tvPromise;
+  };
+}

package/server/remotes/samsung/device-config.js

@@ -0,0 +1,122 @@
+import {
+    getAwakeSamsungDevices,
+    getLastConnectedDevice,
+} from "samsung-tv-remote";
+
+export function normalizeMac(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-f0-9]/g, '');
+}
+
+export function getSamsungDeviceMac(candidate) {
+    return String(candidate?.wifiMac || candidate?.mac || '').trim();
+}
+
+export function pickSamsungDevice(candidates, config) {
+    const requestedHost = String(config.host || '').trim();
+    const requestedMac = normalizeMac(config.mac);
+
+    if (requestedHost) {
+        const byHost = candidates.find((candidate) => candidate.ip === requestedHost);
+        if (byHost) {
+            return byHost;
+        }
+    }
+
+    if (requestedMac) {
+        const byMac = candidates.find((candidate) => normalizeMac(getSamsungDeviceMac(candidate)) === requestedMac);
+        if (byMac) {
+            return byMac;
+        }
+    }
+
+    if (!requestedHost && !requestedMac && candidates.length === 1) {
+        return candidates[0];
+    }
+
+    return null;
+}
+
+function buildDeviceKey(candidate) {
+    const ip = String(candidate?.ip || '').trim();
+    const mac = normalizeMac(getSamsungDeviceMac(candidate));
+    return `${ip}|${mac}`;
+}
+
+export function discoverSamsungDevices({
+                                           getConfig,
+                                           getLastConnectedDeviceFn = getLastConnectedDevice,
+                                           getAwakeSamsungDevicesFn = getAwakeSamsungDevices,
+                                       }) {
+    return async function discoverDevices() {
+        const config = getConfig();
+        const lastDevice = getLastConnectedDeviceFn();
+        const discoveredDevices = await getAwakeSamsungDevicesFn(config.discoveryTimeoutMs);
+        const merged = lastDevice ? [lastDevice, ...discoveredDevices] : discoveredDevices;
+        const seen = new Set();
+
+        return merged.filter((candidate) => {
+            const key = buildDeviceKey(candidate);
+            if (!key || seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+    };
+}
+
+export function createSamsungDeviceConfigResolver({
+                                                      getConfig,
+                                                      getLogger,
+                                                      getLastConnectedDeviceFn = getLastConnectedDevice,
+                                                      getAwakeSamsungDevicesFn = getAwakeSamsungDevices,
+                                                  }) {
+    const discoverDevices = discoverSamsungDevices({
+        getConfig,
+        getLastConnectedDeviceFn,
+        getAwakeSamsungDevicesFn,
+    });
+
+    return async function resolveDeviceConfig() {
+        const config = getConfig();
+        if (!config.alwaysAutoResolve && config.host && config.mac) {
+            return {
+                ip: config.host,
+                mac: config.mac,
+            };
+        }
+
+        const candidates = await discoverDevices();
+        const selectionConfig = config.alwaysAutoResolve
+            ? {...config, host: '', mac: ''}
+            : config;
+        const selected = pickSamsungDevice(candidates, selectionConfig);
+
+        if (!selected) {
+            if (!candidates.length) {
+                throw new Error('aucune TV Samsung reveillee detectee sur le reseau');
+            }
+
+            if (candidates.length > 1) {
+                throw new Error('plusieurs TV Samsung detectees, renseignez SAMSUNG_TV_HOST ou SAMSUNG_TV_MAC');
+            }
+
+            throw new Error('TV Samsung detectee mais impossible de resoudre host/mac');
+        }
+
+        getLogger().info({
+            ip: selected.ip,
+            name: selected.name,
+            model: selected.model,
+            wifiMac: getSamsungDeviceMac(selected),
+        }, 'TV Samsung detectee automatiquement');
+
+        return {
+            ip: selected.ip,
+            mac: getSamsungDeviceMac(selected) || config.mac,
+        };
+    };
+}

package/server/remotes/samsung/registrar.js

@@ -0,0 +1,59 @@
+import {createLogger} from "../../application/logger.js";
+import {
+    REMOTE_EVENT_SAMSUNG_ENTER,
+    REMOTE_EVENT_SAMSUNG_INPUT,
+    REMOTE_EVENT_SAMSUNG_MUTE,
+    REMOTE_EVENT_SAMSUNG_OFF,
+    REMOTE_EVENT_SAMSUNG_ON,
+    REMOTE_EVENT_SAMSUNG_PC_INPUT,
+    REMOTE_EVENT_SAMSUNG_VOL_DOWN,
+    REMOTE_EVENT_SAMSUNG_VOL_UP,
+} from '../../../utils/remoteCommands.js';
+
+let log = createLogger('samsung:remote');
+
+export function createSamsungRegistrar({samsung}) {
+    return socket => {
+        const client = socket.id.slice(0, 8);
+
+        socket.on(REMOTE_EVENT_SAMSUNG_ON, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_ON}`);
+            await samsung.turnOn();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_OFF, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_OFF}`);
+            await samsung.turnOff();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_VOL_UP, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_VOL_UP}`);
+            await samsung.volumeUp();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_VOL_DOWN, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_VOL_DOWN}`);
+            await samsung.volumeDown();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_MUTE, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_MUTE}`);
+            await samsung.mute();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_INPUT, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_INPUT}`);
+            await samsung.switchInput();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_ENTER, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_ENTER}`);
+            await samsung.confirm();
+        });
+
+        socket.on(REMOTE_EVENT_SAMSUNG_PC_INPUT, async () => {
+            log.info({client}, `Demande ${REMOTE_EVENT_SAMSUNG_PC_INPUT}`);
+            await samsung.switchToPcInput();
+        });
+    }
+}

package/server/remotes/samsung/utils.js

@@ -0,0 +1,56 @@
+import {Keys} from "samsung-tv-remote";
+
+export function createDisabledSamsungRemote(reason) {
+    return {
+        isEnabled() {
+            return false;
+        },
+        async turnOn() {
+            return {ok: false, message: reason};
+        },
+        async turnOff() {
+            return {ok: false, message: reason};
+        },
+        async volumeUp() {
+            return {ok: false, message: reason};
+        },
+        async volumeDown() {
+            return {ok: false, message: reason};
+        },
+        async mute() {
+            return {ok: false, message: reason};
+        },
+        async switchInput() {
+            return {ok: false, message: reason};
+        },
+        async confirm() {
+            return {ok: false, message: reason};
+        },
+        async switchToPcInput() {
+            return {ok: false, message: reason};
+        },
+    };
+}
+
+export function toSamsungErrorMessage(error) {
+    return String(error?.message || error || 'Erreur Samsung inconnue');
+}
+
+export function createSamsungResult(message) {
+    return {
+        ok: true,
+        message,
+    };
+}
+
+export function resolveConfiguredKey(keyName) {
+    return Keys[String(keyName || '').trim()] || null;
+}
+
+export function resolveConfiguredKeysSequence(sequence) {
+    return String(sequence || '')
+        .split(',')
+        .map((entry) => String(entry || '').trim().toUpperCase())
+        .filter(Boolean)
+        .map((entry) => Keys[entry] || null);
+}

package/server/remotes/vlc/index.js

@@ -0,0 +1,39 @@
+import { createVlcReceiverState } from './state.js';
+import { VLC_APP_SPEC } from './spec.js';
+
+export function createVlc(services) {
+  const state = createVlcReceiverState();
+  let availabilityPromise = null;
+  const getOsService = () => services.getOs();
+
+  function getAvailability() {
+    if (!availabilityPromise) {
+      availabilityPromise = (async () => {
+        try {
+          const resolved = await getOsService().app.resolve(VLC_APP_SPEC);
+          return Boolean(resolved);
+        } catch (_error) {
+          return false;
+        }
+      })();
+    }
+    return availabilityPromise;
+  }
+
+  return {
+    async focusOrLaunch() {
+      if (state.inFlight) {
+        return false;
+      }
+      state.inFlight = true;
+      try {
+        return getOsService().app.openOrFocus(VLC_APP_SPEC, { maximize: false });
+      } finally {
+        state.inFlight = false;
+      }
+    },
+    toggleWindow: () => getOsService().app.toggleWindow(VLC_APP_SPEC),
+    closeWindow: () => getOsService().app.closeWindow(VLC_APP_SPEC),
+    isAvailable: getAvailability,
+  };
+}