@velor/remote-mouse 6.4.8

package/server/os/win32/service.js

@@ -0,0 +1,95 @@
+import {
+    getEntrypoint,
+    getPlatformKind,
+    isDaemonProcess
+} from "../../services/application/utils.js";
+import {
+    execFileAsync,
+    spawnDetached
+} from "../../utils/process.js";
+
+function buildWindowsTaskCommand() {
+    const nodePath = process.execPath.replace(/'/g, "''");
+    const entrypoint = getEntrypoint().replace(/'/g, "''");
+    return `powershell -NoProfile -WindowStyle Hidden -Command "$env:REMOTE_MOUSE_DAEMON='1'; & '${nodePath}' '${entrypoint}'"`;
+}
+
+export async function installWindowsDaemon(serviceName) {
+    const result = await execFileAsync('schtasks', [
+        '/Create',
+        '/F',
+        '/SC', 'ONLOGON',
+        '/TN', serviceName,
+        '/TR', buildWindowsTaskCommand(),
+    ], {timeout: 30000});
+
+    if (!result.ok) {
+        return {ok: false, message: result.stderr || `Impossible d'installer la tache ${serviceName}.`};
+    }
+
+    const run = await execFileAsync('schtasks', ['/Run', '/TN', serviceName], {timeout: 10000});
+    if (!run.ok) {
+        return {ok: false, message: run.stderr || `Tache ${serviceName} creee mais non lancee.`};
+    }
+
+    return {
+        ok: true,
+        message: `Tache ${serviceName} installee et lancee.`,
+    };
+}
+
+export async function disableWindowsDaemon(serviceName) {
+    await execFileAsync('schtasks', ['/End', '/TN', serviceName], {timeout: 10000});
+    const result = await execFileAsync('schtasks', ['/Change', '/TN', serviceName, '/Disable'], {timeout: 30000});
+    if (!result.ok) {
+        return {ok: false, message: result.stderr || `Impossible de desactiver la tache ${serviceName}.`};
+    }
+
+    return {
+        ok: true,
+        message: `Tache ${serviceName} desactivee.`,
+    };
+}
+
+export async function uninstallWindowsDaemon(serviceName) {
+    await execFileAsync('schtasks', ['/End', '/TN', serviceName], {timeout: 10000});
+    const result = await execFileAsync('schtasks', ['/Delete', '/TN', serviceName, '/F'], {timeout: 30000});
+    if (!result.ok) {
+        return {ok: false, message: result.stderr || `Impossible de supprimer la tache ${serviceName}.`};
+    }
+
+    return {
+        ok: true,
+        message: `Tache ${serviceName} desinstallee.`,
+    };
+}
+
+export async function restartWindowsDaemon(serviceName) {
+    const command = `Start-Sleep -Milliseconds 800; schtasks /End /TN "${serviceName}" 2>$null; schtasks /Run /TN "${serviceName}"`;
+    const spawned = await spawnDetached('powershell', ['-NoProfile', '-Command', command]);
+
+    if (!spawned) {
+        return {
+            ok: false,
+            message: 'Impossible de lancer la tache de redemarrage.',
+            details: {message: 'spawn schtasks failed'},
+        };
+    }
+
+    return {
+        ok: true,
+        message: `Redemarrage demande pour ${serviceName}.`,
+    };
+}
+
+export async function getWindowsDaemonInfo(serviceName) {
+    const result = await execFileAsync('schtasks', ['/Query', '/TN', serviceName], {timeout: 5000});
+
+    return {
+        serviceName,
+        platform: process.platform,
+        platformKind: getPlatformKind(),
+        runningAsDaemon: isDaemonProcess(),
+        installed: result.ok,
+    };
+}

package/server/os/win32/url.js

@@ -0,0 +1,9 @@
+import {spawnDetached} from '../../utils/process.js';
+
+export async function openWin32Url(url) {
+  const safeUrl = String(url || '').trim();
+  if (!safeUrl) {
+    return false;
+  }
+  return spawnDetached('cmd', ['/c', 'start', '', safeUrl]);
+}

package/server/os/win32/window.js

@@ -0,0 +1,10 @@
+import {execFileAsync} from '../../utils/process.js';
+import {buildForegroundWindowPowerShell} from './powershell.js';
+
+export async function toggleWin32ActiveWindow() {
+  return (await execFileAsync('powershell', ['-NoProfile', '-Command', buildForegroundWindowPowerShell('toggle')])).ok;
+}
+
+export async function closeWin32ActiveWindow() {
+  return (await execFileAsync('powershell', ['-NoProfile', '-Command', buildForegroundWindowPowerShell('close')])).ok;
+}

package/server/remotes/admin/createAdminEventGuardMiddleware.js

@@ -0,0 +1,29 @@
+import { REMOTE_EVENT_ADMIN_PREFIX } from '../../../utils/remoteCommands.js';
+
+export function createAdminEventGuardMiddleware({
+  isAdminActionsEnabled,
+  client,
+  log,
+  respondAdminAction,
+}) {
+  return function adminEventGuard(packet, next) {
+    const eventName = String(packet?.[0] || '');
+    if (!eventName.startsWith(REMOTE_EVENT_ADMIN_PREFIX)) {
+      next();
+      return;
+    }
+
+    if (isAdminActionsEnabled) {
+      next();
+      return;
+    }
+
+    const action = eventName.replace(REMOTE_EVENT_ADMIN_PREFIX, '');
+    log.warn({ client, action }, 'Action admin refusée: ADMIN_ACTIONS_ENABLED=false');
+    respondAdminAction(action, {
+      ok: false,
+      message: 'Actions admin desactivees.',
+    });
+    next(new Error('admin_actions_disabled'));
+  };
+}

package/server/remotes/admin/createForceUpdateCheckAction.js

@@ -0,0 +1,39 @@
+import {createLogger} from '../../application/logger.js';
+import {
+    PUBSUB_EVENT_ADMIN_COMPLETED,
+    PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK
+} from "../../services/pubsub/serviceEventConstants.js";
+
+let log;
+function getModuleLog() {
+    log ??= createLogger('admin:force-update-check');
+    return log;
+}
+
+export function createForceUpdateCheckAction(services) {
+    const log = getModuleLog();
+    const {
+        getEvents,
+        getUpdateManager
+    } = services;
+    return async function forceUpdateCheck({clientId} = {}) {
+        log.info('Début force update check');
+        const result = await getUpdateManager().check();
+
+        if (result && result.checked && result.hasUpdate) {
+            log.info('Force update check: mise à jour détectée');
+            getEvents().publishEvent(PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK, PUBSUB_EVENT_ADMIN_COMPLETED, {
+                clientId,
+                hasUpdate: true,
+            });
+            return {ok: true, message: 'Mise a jour detectee.'};
+        }
+
+        log.info('Force update check: aucune mise à jour détectée');
+        getEvents().publishEvent(PUBSUB_SERVICE_ADMIN_FORCE_UPDATE_CHECK, PUBSUB_EVENT_ADMIN_COMPLETED, {
+            clientId,
+            hasUpdate: false,
+        });
+        return {ok: true, message: 'Aucune mise a jour detectee.'};
+    };
+}

package/server/remotes/admin/createInstallUpdateAction.js

@@ -0,0 +1,64 @@
+import {createLogger} from '../../application/logger.js';
+import {
+  PUBSUB_EVENT_ADMIN_COMPLETED,
+  PUBSUB_EVENT_ADMIN_FAILED,
+  PUBSUB_EVENT_ADMIN_REJECTED_NO_COMMAND,
+  PUBSUB_EVENT_ADMIN_STARTED,
+  PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('admin:install-update');
+  return log;
+}
+
+export function createInstallUpdateAction(services) {
+  const log = getModuleLog();
+  return async function installUpdate({ clientId } = {}) {
+    const events = services.getEvents();
+    const updateManager = services.getUpdateManager();
+    const restartService = services.getRemotes().adminActions.restartService;
+    log.info('Début install update');
+
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE, PUBSUB_EVENT_ADMIN_STARTED, {
+      clientId,
+    });
+
+    const result = await updateManager.update();
+    if (result?.ok) {
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE, PUBSUB_EVENT_ADMIN_COMPLETED, {
+        clientId,
+      });
+      const restartResult = await restartService({ clientId });
+      if (!restartResult?.ok) {
+        return {
+          ok: false,
+          message: restartResult?.message || 'Installation terminee, mais le redemarrage a echoue.',
+        };
+      }
+      return {
+        ok: true,
+        message: result.message || 'Installation terminee. Redemarrage demande.',
+      };
+    }
+
+    if (result?.status === 'no-command') {
+      log.warn('Install update impossible: aucune commande disponible');
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE, PUBSUB_EVENT_ADMIN_REJECTED_NO_COMMAND, {
+        clientId,
+      });
+      return {
+        ok: false,
+        message: result.message || 'Aucune commande update disponible.',
+      };
+    }
+
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_INSTALL_UPDATE, PUBSUB_EVENT_ADMIN_FAILED, {
+      clientId,
+      details: result?.details,
+    });
+
+    return { ok: false, message: result?.message || 'Echec installation: Erreur inconnue' };
+  };
+}

package/server/remotes/admin/createOpenQrBrowserAction.js

@@ -0,0 +1,63 @@
+import {createLogger} from '../../application/logger.js';
+import {
+  NOTIFIER_TARGET_CLIENT,
+  NOTIFIER_TARGET_SERVER,
+} from '../../services/notifier/createNotifierComposite.js';
+import {
+  PUBSUB_EVENT_ADMIN_CLIENT_OPENED,
+  PUBSUB_EVENT_ADMIN_SERVER_OPEN_FAILED,
+  PUBSUB_EVENT_ADMIN_SERVER_OPENED,
+  PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('admin:open-qr-browser');
+  return log;
+}
+
+function publishClientEvent(events, type, clientId) {
+  if (!clientId) {
+    return;
+  }
+  events.publishEvent(PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER, type, {
+    clientId,
+  });
+}
+
+export function createOpenQrBrowserAction(services, options = {}) {
+  const log = getModuleLog();
+  const browser = options.browser;
+  const target = options.target || NOTIFIER_TARGET_SERVER;
+
+  return async function openQrBrowser({ clientId } = {}) {
+    const events = services.getEvents();
+    const isClientTarget = target === NOTIFIER_TARGET_CLIENT;
+    const clientQrUrl = '/qr';
+
+    if (isClientTarget) {
+      log.info({ clientId, clientQrUrl }, 'Ouverture de la page QR sur le client');
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_OPEN_QR_BROWSER, PUBSUB_EVENT_ADMIN_CLIENT_OPENED, {
+        clientId,
+      });
+      return {
+        ok: true,
+        message: 'Page QR ouverte sur le client.',
+        openUrl: clientQrUrl,
+      };
+    }
+
+    const config = services.getSystemConfig();
+    const localQrUrl = `${config.protocol}://127.0.0.1:${config.port}/qr`;
+    log.info({ localQrUrl }, 'Ouverture de la page QR sur le serveur');
+
+    const ok = await browser.openUrlOnHost(localQrUrl);
+    if (!ok) {
+      publishClientEvent(events, PUBSUB_EVENT_ADMIN_SERVER_OPEN_FAILED, clientId);
+      return {ok: false, message: 'Impossible d’ouvrir /qr sur le serveur.'};
+    }
+
+    publishClientEvent(events, PUBSUB_EVENT_ADMIN_SERVER_OPENED, clientId);
+    return {ok: true, message: 'Page QR ouverte sur le serveur.'};
+  };
+}

package/server/remotes/admin/createOpenServerInfoBrowserAction.js

@@ -0,0 +1,58 @@
+import {createLogger} from '../../application/logger.js';
+import {
+  NOTIFIER_TARGET_CLIENT,
+  NOTIFIER_TARGET_SERVER,
+} from '../../services/notifier/createNotifierComposite.js';
+import {
+  PUBSUB_EVENT_ADMIN_CLIENT_OPENED,
+  PUBSUB_EVENT_ADMIN_SERVER_OPEN_FAILED,
+  PUBSUB_EVENT_ADMIN_SERVER_OPENED,
+  PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('admin:open-server-info-browser');
+  return log;
+}
+
+export function createOpenServerInfoBrowserAction(services, options = {}) {
+  const log = getModuleLog();
+  const browser = options.browser;
+  const target = options.target || NOTIFIER_TARGET_SERVER;
+
+  return async function openServerInfoBrowser({ clientId } = {}) {
+    const events = services.getEvents();
+    const isClientTarget = target === NOTIFIER_TARGET_CLIENT;
+    const clientInfoUrl = '/ui/admin/server-info';
+
+    if (isClientTarget) {
+      log.info({ clientId, clientInfoUrl }, 'Ouverture de la page server info sur le client');
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER, PUBSUB_EVENT_ADMIN_CLIENT_OPENED, {
+        clientId,
+      });
+      return {
+        ok: true,
+        message: 'Page server info ouverte sur le client.',
+        openUrl: clientInfoUrl,
+      };
+    }
+
+    const config = services.getSystemConfig();
+    const localInfoUrl = `${config.protocol}://127.0.0.1:${config.port}/ui/admin/server-info`;
+    log.info({ localInfoUrl }, 'Ouverture de la page server info sur le serveur');
+
+    const ok = await browser.openUrlOnHost(localInfoUrl);
+    if (!ok) {
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER, PUBSUB_EVENT_ADMIN_SERVER_OPEN_FAILED, {
+        clientId,
+      });
+      return {ok: false, message: "Impossible d'ouvrir server info sur le serveur."};
+    }
+
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_OPEN_SERVER_INFO_BROWSER, PUBSUB_EVENT_ADMIN_SERVER_OPENED, {
+      clientId,
+    });
+    return {ok: true, message: 'Page server info ouverte sur le serveur.'};
+  };
+}

package/server/remotes/admin/createRestartServiceAction.js

@@ -0,0 +1,20 @@
+import {
+  PUBSUB_EVENT_ADMIN_STARTED,
+  PUBSUB_SERVICE_ADMIN_RESTART_SERVICE,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+export function createRestartServiceAction(services) {
+  return async function restartService({ clientId } = {}) {
+    const events = services.getEvents();
+    const config = services.getSystemConfig();
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_RESTART_SERVICE, PUBSUB_EVENT_ADMIN_STARTED, {
+      clientId,
+      serviceName: config.serviceName,
+    });
+
+    return services.getApplicationDaemonService().restart({
+      cause: 'user',
+      source: 'admin-remote',
+    });
+  };
+}

package/server/remotes/admin/createRotateEntryTokenAction.js

@@ -0,0 +1,43 @@
+import {
+  PUBSUB_EVENT_ADMIN_REJECTED_DISABLED,
+  PUBSUB_EVENT_ADMIN_ROTATED,
+  PUBSUB_EVENT_ADMIN_UNCHANGED,
+  PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN,
+} from '../../services/pubsub/serviceEventConstants.js';
+import {createLogger} from '../../application/logger.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('admin:rotate-entry-token');
+  return log;
+}
+
+export function createRotateEntryTokenAction(services) {
+  const log = getModuleLog();
+  return async function rotateEntryToken({ clientId } = {}) {
+    const events = services.getEvents();
+    const tokenManager = services.getTokenManager();
+    const before = String(tokenManager.getToken());
+    const after = String(tokenManager.createToken());
+
+    if (!after) {
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN, PUBSUB_EVENT_ADMIN_REJECTED_DISABLED, {
+        clientId,
+      });
+      return { ok: false, message: 'Entry path desactive.' };
+    }
+
+    if (after === before) {
+      events.publishEvent(PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN, PUBSUB_EVENT_ADMIN_UNCHANGED, {
+        clientId,
+      });
+      return { ok: false, message: 'Token non change (mode fixe ou rotation indisponible).' };
+    }
+
+    log.info('Token d entree force en rotation');
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_ROTATE_ENTRY_TOKEN, PUBSUB_EVENT_ADMIN_ROTATED, {
+      clientId,
+    });
+    return { ok: true, message: 'Token d entree rotation forcee.' };
+  };
+}

package/server/remotes/admin/createToggleQrOverlayAction.js

@@ -0,0 +1,38 @@
+import {createLogger} from '../../application/logger.js';
+import {
+  PUBSUB_EVENT_ADMIN_TOGGLED,
+  PUBSUB_SERVICE_ADMIN_TOGGLE_QR_OVERLAY,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+let log;
+function getModuleLog() {
+  log ??= createLogger('admin:toggle-qr-overlay');
+  return log;
+}
+
+export function createToggleQrOverlayAction(services) {
+  const log = getModuleLog();
+  const getEvents = services.getEvents;
+  const getQrOverlay = services.getQrOverlay;
+
+  return async function toggleQrOverlay({ clientId } = {}) {
+    const events = getEvents();
+    const qrOverlay = getQrOverlay();
+    if (!qrOverlay || typeof qrOverlay.toggle !== 'function') {
+      return { ok: false, message: 'QR overlay indisponible.' };
+    }
+
+    const visible = await qrOverlay.toggle();
+    const message = visible
+      ? 'QR overlay affiche.'
+      : 'QR overlay masque.';
+
+    log.info({ visible }, 'Toggle QR overlay');
+    events.publishEvent(PUBSUB_SERVICE_ADMIN_TOGGLE_QR_OVERLAY, PUBSUB_EVENT_ADMIN_TOGGLED, {
+      clientId,
+      visible,
+    });
+
+    return { ok: true, message };
+  };
+}

package/server/remotes/admin/index.js

@@ -0,0 +1,32 @@
+import {createForceUpdateCheckAction} from './createForceUpdateCheckAction.js';
+import {createInstallUpdateAction} from './createInstallUpdateAction.js';
+import {createRestartServiceAction} from './createRestartServiceAction.js';
+import {createOpenQrBrowserAction} from './createOpenQrBrowserAction.js';
+import {createOpenServerInfoBrowserAction} from './createOpenServerInfoBrowserAction.js';
+import {createRotateEntryTokenAction} from './createRotateEntryTokenAction.js';
+import {createToggleQrOverlayAction} from './createToggleQrOverlayAction.js';
+import {notifyIfRestarted} from './notifyIfRestarted.js';
+
+export {notifyIfRestarted};
+
+import {
+    NOTIFIER_TARGET_CLIENT,
+    NOTIFIER_TARGET_SERVER
+} from '../../services/notifier/createNotifierComposite.js';
+import {createBrowser} from '../browser/index.js';
+
+export function createAdminActions(services) {
+    const browser = createBrowser(services.getOs());
+
+    return {
+        forceUpdateCheck: createForceUpdateCheckAction(services),
+        installUpdate: createInstallUpdateAction(services),
+        restartService: createRestartServiceAction(services),
+        openQrBrowserServer: createOpenQrBrowserAction(services, {browser, target: NOTIFIER_TARGET_SERVER}),
+        openQrBrowserClient: createOpenQrBrowserAction(services, {browser, target: NOTIFIER_TARGET_CLIENT}),
+        openServerInfoBrowserServer: createOpenServerInfoBrowserAction(services, {browser, target: NOTIFIER_TARGET_SERVER}),
+        openServerInfoBrowserClient: createOpenServerInfoBrowserAction(services, {browser, target: NOTIFIER_TARGET_CLIENT}),
+        rotateEntryToken: createRotateEntryTokenAction(services),
+        toggleQrOverlay: createToggleQrOverlayAction(services),
+    };
+}

package/server/remotes/admin/notifyIfRestarted.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {isDaemonProcess} from '../../services/application/utils.js';
+import {
+  PUBSUB_EVENT_ADMIN_RESTART_DETECTED,
+  PUBSUB_SERVICE_ADMIN_RESTART_SERVICE,
+} from '../../services/pubsub/serviceEventConstants.js';
+
+const RESTART_MARKER_FILE = path.join(os.tmpdir(), 'remote-mouse-restarted.marker');
+const RECENT_RESTART_WINDOW_MS = 60_000;
+let lastRestartDetectedAt = 0;
+
+export function writeRestartMarker(payload = {}) {
+  try {
+    fs.writeFileSync(RESTART_MARKER_FILE, JSON.stringify({
+      requestedAt: Date.now(),
+      ...payload,
+    }), 'utf8');
+  } catch (_error) {
+    // best effort
+  }
+}
+
+function readAndClearRestartMarker() {
+  try {
+    if (!fs.existsSync(RESTART_MARKER_FILE)) {
+      return null;
+    }
+    const raw = fs.readFileSync(RESTART_MARKER_FILE, 'utf8');
+    fs.unlinkSync(RESTART_MARKER_FILE);
+    return JSON.parse(raw || '{}');
+  } catch (_error) {
+    return null;
+  }
+}
+
+function getDaemonStartupCause() {
+  return os.uptime() <= 300 ? 'reboot' : 'unexpected';
+}
+
+export function notifyIfRestarted(services) {
+  const restartLogDao = services.getPersistence().restartLogDao;
+  const marker = readAndClearRestartMarker();
+  const startupAt = Date.now();
+  const startupCause = isDaemonProcess() ? getDaemonStartupCause() : 'user';
+
+  const lastEvent = restartLogDao?.getLastLifecycleEvent?.();
+  if (lastEvent?.eventType === 'start') {
+    restartLogDao.createLifecycleEvent({
+      eventAt: startupAt,
+      eventType: 'stop',
+      cause: startupCause,
+      source: 'inferred-stop',
+      status: 'completed',
+      details: {
+        inferred: true,
+        previousStartAt: lastEvent.requestedAt,
+        systemUptimeSec: Math.floor(os.uptime()),
+      },
+    });
+  }
+
+  if (marker) {
+    lastRestartDetectedAt = startupAt;
+    restartLogDao?.updateRestartStatus(marker.restartId, {
+      detectedAt: lastRestartDetectedAt,
+      status: 'completed',
+      details: {
+        restartDetectedAt: lastRestartDetectedAt,
+      },
+    });
+    restartLogDao?.createLifecycleEvent({
+      eventAt: startupAt,
+      eventType: 'start',
+      cause: String(marker.cause || 'user'),
+      source: 'restart-marker',
+      status: 'completed',
+      details: {
+        restartId: marker.restartId ?? null,
+      },
+    });
+    services.getEvents().publishEvent(PUBSUB_SERVICE_ADMIN_RESTART_SERVICE, PUBSUB_EVENT_ADMIN_RESTART_DETECTED, {});
+    return;
+  }
+
+  restartLogDao?.createLifecycleEvent({
+    eventAt: startupAt,
+    eventType: 'start',
+    cause: startupCause,
+    source: isDaemonProcess() ? 'daemon-startup' : 'manual-startup',
+    status: 'completed',
+    details: {
+      restartDetectedAt: startupAt,
+      systemUptimeSec: Math.floor(os.uptime()),
+    },
+  });
+}
+
+export function hasRecentRestart() {
+  return lastRestartDetectedAt > 0 && (Date.now() - lastRestartDetectedAt) <= RECENT_RESTART_WINDOW_MS;
+}