@livedesk/hub 0.1.3 → 0.1.5

package/src/live-desk-update.js

@@ -0,0 +1,457 @@
+import { randomUUID } from 'node:crypto';
+
+export const LIVE_DESK_UPDATE_COMMAND = 'livedesk.client-update';
+// 0.1.143 contains the launcher-PID-aware updater. Older clients use the
+// Hub-generated legacy command so they can still be upgraded safely.
+export const LIVE_DESK_DEDICATED_CLIENT_UPDATE_MIN_VERSION = '0.1.143';
+export const LIVE_DESK_UPDATE_TIMEOUT_MS = 180_000;
+export const LIVE_DESK_UPDATE_CHECK_INTERVAL_MS = 60_000;
+
+function cleanVersion(value) {
+  return String(value || '').trim().replace(/^v/i, '');
+}
+
+export function compareVersions(left, right) {
+  const a = cleanVersion(left).split(/[+-]/, 1)[0].split('.').map(part => Number(part) || 0);
+  const b = cleanVersion(right).split(/[+-]/, 1)[0].split('.').map(part => Number(part) || 0);
+  const length = Math.max(a.length, b.length, 3);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (a[index] || 0) - (b[index] || 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+
+export function isVersionAtLeast(candidate, required) {
+  return !!cleanVersion(candidate) && !!cleanVersion(required) && compareVersions(candidate, required) >= 0;
+}
+
+function encodePowerShell(value) {
+  return Buffer.from(String(value || ''), 'utf16le').toString('base64');
+}
+
+function quotePowerShell(value) {
+  return `'${String(value ?? '').replaceAll("'", "''")}'`;
+}
+
+function buildWindowsLegacyUpdateCommand({ manager, pair, name, slot, targetVersion }) {
+  const script = [
+    '$ErrorActionPreference = "Stop"',
+    '$cursor = Get-CimInstance Win32_Process -Filter ("ProcessId={0}" -f $PID)',
+    '$launcherPid = 0',
+    '$configuredLauncherPid = 0',
+    'if ([int]::TryParse([string]$env:LIVEDESK_CLIENT_PARENT_PID, [ref]$configuredLauncherPid) -and $configuredLauncherPid -gt 1) { try { Get-Process -Id $configuredLauncherPid -ErrorAction Stop | Out-Null; $launcherPid = $configuredLauncherPid } catch {} }',
+    'if ($launcherPid -le 0) {',
+    '  for ($depth = 0; $depth -lt 12 -and $cursor; $depth++) {',
+    '    $parent = Get-CimInstance Win32_Process -Filter ("ProcessId={0}" -f [int]$cursor.ParentProcessId)',
+    '    if (-not $parent) { break }',
+    '    $commandLine = [string]$parent.CommandLine',
+    '    if ($commandLine -match "(?i)(livedesk-client\\.js|livedesk\\.js)") { $launcherPid = [int]$parent.ProcessId; break }',
+    '    $cursor = $parent',
+    '  }',
+    '}',
+    'if ($launcherPid -le 0) { throw "LiveDesk client launcher process was not found." }',
+    `$env:LIVEDESK_CLIENT_MANAGER = ${quotePowerShell(manager)}`,
+    `$env:LIVEDESK_CLIENT_PAIR_TOKEN = ${quotePowerShell(pair)}`,
+    `$env:LIVEDESK_CLIENT_NAME = ${quotePowerShell(name)}`,
+    `$env:LIVEDESK_CLIENT_SLOT = ${quotePowerShell(slot || '')}`,
+    `$env:LIVEDESK_CLIENT_UPDATE_TARGET_VERSION = ${quotePowerShell(targetVersion)}`,
+    '$node = [string]$env:LIVEDESK_NODE_EXECUTABLE',
+    'if ($node -and -not (Test-Path -LiteralPath $node -PathType Leaf)) { $node = "" }',
+    'if (-not $node) { $node = (Get-Command node.exe -ErrorAction SilentlyContinue).Source }',
+    'if (-not $node) { throw "LiveDesk node executable was not found." }',
+    `$env:LIVEDESK_UPDATE_BOOTSTRAP_BASE64 = ${quotePowerShell(Buffer.from(buildUnixClientUpdateBootstrapScript(), 'utf8').toString('base64'))}`,
+    '$env:LIVEDESK_UPDATE_WAIT_PID = [string]$launcherPid',
+    '$env:LIVEDESK_UPDATE_AGENT_PID = "0"',
+    '$bootstrapRunner = "eval(Buffer.from(process.env.LIVEDESK_UPDATE_BOOTSTRAP_BASE64, \'base64\').toString(\'utf8\'))"',
+    'Start-Process -FilePath $node -ArgumentList @("-e", $bootstrapRunner) -WindowStyle Hidden',
+    'Start-Sleep -Milliseconds 750',
+    'Start-Process -FilePath "taskkill.exe" -ArgumentList @("/PID", [string]$launcherPid, "/T", "/F") -WindowStyle Hidden',
+    ''
+  ].join('\r\n');
+  return `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encodePowerShell(script)}`;
+}
+
+function buildUnixClientUpdateBootstrapScript() {
+  return [
+    'const { spawn } = require("node:child_process");',
+    'const fs = require("node:fs");',
+    'const path = require("node:path");',
+    'const waitPid = Number(process.env.LIVEDESK_UPDATE_WAIT_PID || 0);',
+    'const agentPid = Number(process.env.LIVEDESK_UPDATE_AGENT_PID || 0);',
+    'const isAlive = pid => { try { process.kill(pid, 0); return true; } catch (error) { return error?.code !== "ESRCH"; } };',
+    'const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));',
+    'const waitForExit = async pid => { for (let attempt = 0; attempt < 360 && pid > 1; attempt += 1) { if (!isAlive(pid)) return; await sleep(500); } if (pid > 1 && isAlive(pid)) throw new Error("LiveDesk client process did not exit before update installation."); };',
+    'const nodeDir = path.dirname(process.execPath);',
+    'const npxCandidates = process.platform === "win32" ? [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeDir, "npx.cmd"), path.join(nodeDir, "npx.exe"), "npx.cmd"] : [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeDir, "npx"), "npx"];',
+    'const npx = npxCandidates.find(candidate => !path.isAbsolute(candidate) || fs.existsSync(candidate)) || npxCandidates[npxCandidates.length - 1];',
+    'const npmExecPath = String(process.env.npm_execpath || process.env.NPM_EXECPATH || "").trim();',
+    'const npxCliCandidates = [process.env.LIVEDESK_NPX_CLI_PATH, npmExecPath ? path.join(path.dirname(npmExecPath), "npx-cli.js") : "", path.join(nodeDir, "node_modules", "npm", "bin", "npx-cli.js")].filter(Boolean);',
+    'const npxCli = npxCliCandidates.find(candidate => fs.existsSync(candidate));',
+    'const npxArgs = ["-y", "--prefer-online", "livedesk@latest", "--force-role", "client", "--no-login", "--no-open"];',
+    'const command = npxCli ? process.execPath : (process.platform === "win32" ? (process.env.ComSpec || "cmd.exe") : npx);',
+    'const commandArgs = npxCli ? [npxCli, ...npxArgs] : (process.platform === "win32" ? ["/d", "/s", "/c", "call \\"" + npx + "\\" " + npxArgs.join(" ")] : npxArgs);',
+    'process.env.LIVEDESK_SKIP_BROWSER_OPEN = "1";',
+    '(async () => { await waitForExit(waitPid); await waitForExit(agentPid); const updater = spawn(command, commandArgs, { detached: true, stdio: "ignore", windowsHide: true, env: process.env }); updater.once("error", error => { console.error("LiveDesk updater failed to start: " + error.message); process.exitCode = 1; }); updater.once("spawn", () => updater.unref()); })().catch(error => { console.error("LiveDesk updater failed: " + error.message); process.exitCode = 1; });',
+    ''
+  ].join('\n');
+}
+
+function buildUnixLegacyUpdateCommand({ manager, pair, name, slot, targetVersion }) {
+  const script = [
+    'const { execFileSync, spawn } = require("node:child_process");',
+    'const fs = require("node:fs");',
+    'const path = require("node:path");',
+    'const parentOf = pid => { try { return Number(execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8" }).trim()) || 0; } catch { return 0; } };',
+    'const commandOf = pid => { try { return execFileSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" }); } catch { return ""; } };',
+    'const isAlive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } };',
+    'const configuredLauncherPid = Number(process.env.LIVEDESK_CLIENT_PARENT_PID || 0);',
+    'let launcherPid = Number.isInteger(configuredLauncherPid) && configuredLauncherPid > 1 && isAlive(configuredLauncherPid) ? configuredLauncherPid : 0;',
+    'let agentPid = Number(process.env.LIVEDESK_CLIENT_AGENT_PID || 0);',
+    'let cursor = parentOf(process.pid);',
+    'for (let depth = 0; depth < 12 && cursor; depth++) { const command = commandOf(cursor); if (!agentPid && /livedesk-client-node\\.js|livedesk-client-fast|RemoteAgent\\.Fast/i.test(command)) agentPid = cursor; if (!launcherPid && /livedesk-client\\.js|livedesk\\.js/i.test(command)) launcherPid = cursor; cursor = parentOf(cursor); }',
+    'if (launcherPid <= 1) throw new Error("LiveDesk client launcher process was not found.");',
+    'const waitPid = launcherPid;',
+    `process.env.LIVEDESK_CLIENT_MANAGER = ${JSON.stringify(String(manager || ''))};`,
+    `process.env.LIVEDESK_CLIENT_PAIR_TOKEN = ${JSON.stringify(String(pair || ''))};`,
+    `process.env.LIVEDESK_CLIENT_NAME = ${JSON.stringify(String(name || ''))};`,
+    `process.env.LIVEDESK_CLIENT_SLOT = ${JSON.stringify(String(slot || ''))};`,
+    `process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION = ${JSON.stringify(String(targetVersion || ''))};`,
+    `const bootstrapScript = ${JSON.stringify(buildUnixClientUpdateBootstrapScript())};`,
+    'const bootstrapEnv = { ...process.env, LIVEDESK_UPDATE_WAIT_PID: String(waitPid), LIVEDESK_UPDATE_AGENT_PID: String(agentPid) };',
+    'const updater = spawn(process.execPath, ["-e", bootstrapScript], { detached: true, stdio: "ignore", env: bootstrapEnv });',
+    'updater.once("error", error => { console.error("LiveDesk updater bootstrap failed to start: " + error.message); process.exitCode = 1; });',
+    'updater.once("spawn", () => { updater.unref(); setTimeout(() => { try { process.kill(waitPid, "SIGTERM"); } catch {} if (agentPid > 1 && agentPid !== process.pid) setTimeout(() => { try { process.kill(agentPid, "SIGTERM"); } catch {} }, 500); }, 750); });',
+    ''
+  ].join('\n');
+  return [
+    'if [ -n "$LIVEDESK_NODE_EXECUTABLE" ]; then node_bin="$LIVEDESK_NODE_EXECUTABLE"; else node_bin="$(ps -p "$LIVEDESK_CLIENT_PARENT_PID" -o comm= 2>/dev/null | sed "s/^ *//")"; if [ -z "$node_bin" ]; then node_bin="node"; fi; fi',
+    `"$node_bin" -e ${JSON.stringify(script)}`
+  ].join('\n');
+}
+
+function buildLegacyUpdateCommand(device, credentials, targetVersion) {
+  const payload = {
+    manager: credentials.manager,
+    pair: credentials.pairToken,
+    name: device.deviceName || device.hostname || '',
+    slot: device.slotNumber || '',
+    targetVersion
+  };
+  return ['win32', 'windows'].includes(String(device.platform || '').toLowerCase())
+    ? buildWindowsLegacyUpdateCommand(payload)
+    : buildUnixLegacyUpdateCommand(payload);
+}
+
+async function fetchLatestPackage(packageName, fetchImpl) {
+  const encodedName = packageName.startsWith('@') ? packageName.replace('/', '%2F') : packageName;
+  const response = await fetchImpl(`https://registry.npmjs.org/${encodedName}/latest`, {
+    headers: { Accept: 'application/json' },
+    signal: AbortSignal.timeout(12_000)
+  });
+  if (!response.ok) {
+    throw new Error(`npm registry returned HTTP ${response.status} for ${packageName}.`);
+  }
+  const payload = await response.json();
+  const version = cleanVersion(payload?.version);
+  if (!version) throw new Error(`npm registry returned no version for ${packageName}.`);
+  return { version, package: payload };
+}
+
+export async function fetchLatestLiveDeskRelease(fetchImpl = globalThis.fetch) {
+  if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for LiveDesk update checks.');
+  const [manager, client] = await Promise.all([
+    fetchLatestPackage('livedesk', fetchImpl),
+    fetchLatestPackage('@livedesk/client', fetchImpl)
+  ]);
+  return {
+    latestManagerVersion: manager.version,
+    latestClientVersion: client.version,
+    managerPackage: manager.package,
+    clientPackage: client.package,
+    checkedAt: new Date().toISOString()
+  };
+}
+
+function statusForRun(run) {
+  if (!run) return null;
+  return {
+    operationId: run.operationId,
+    state: run.state,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    targetCount: run.targets.length,
+    completedCount: run.targets.filter(target => target.state === 'completed').length,
+    waitingCount: run.targets.filter(target => target.state === 'waiting').length,
+    failedCount: run.targets.filter(target => target.state === 'failed').length,
+    error: run.error || '',
+    targets: run.targets.map(target => ({ ...target }))
+  };
+}
+
+function connectedDevices(remoteHub) {
+  return remoteHub.listDevices({ includeDataUrl: false })
+    .filter(device => device.connected === true && device.synthetic !== true)
+    .slice(0, 500);
+}
+
+export function createLiveDeskUpdateManager({
+  remoteHub,
+  currentManagerVersion,
+  currentClientVersion,
+  restartSupported = false,
+  requestHubRestart,
+  fetchImpl = globalThis.fetch,
+  now = () => Date.now()
+}) {
+  let latestRelease = null;
+  let checkError = '';
+  let checkPromise = null;
+  let run = null;
+  let checkTimer = null;
+  let runTimer = null;
+
+  const touch = () => {
+    if (run) run.updatedAt = new Date(now()).toISOString();
+  };
+
+  const checkLatest = async () => {
+    if (checkPromise) return checkPromise;
+    checkPromise = fetchLatestLiveDeskRelease(fetchImpl)
+      .then(release => {
+        latestRelease = release;
+        checkError = '';
+        return release;
+      })
+      .catch(error => {
+        checkError = error instanceof Error ? error.message : String(error);
+        return null;
+      })
+      .finally(() => {
+        checkPromise = null;
+      });
+    return checkPromise;
+  };
+
+  const getStatus = () => {
+    const managerUpdateAvailable = !!latestRelease
+      && compareVersions(latestRelease.latestManagerVersion, currentManagerVersion) > 0;
+    const clientDevices = connectedDevices(remoteHub);
+    const outdatedClientDevices = latestRelease
+      ? clientDevices.filter(device => !isVersionAtLeast(device.agentVersion, latestRelease.latestClientVersion))
+      : [];
+    const clientPackageUpdateAvailable = !!latestRelease
+      && compareVersions(latestRelease.latestClientVersion, currentClientVersion) > 0;
+    const clientUpdateAvailable = clientPackageUpdateAvailable || outdatedClientDevices.length > 0;
+    const updateAvailable = managerUpdateAvailable || clientUpdateAvailable;
+    const activeRun = statusForRun(run);
+    return {
+      currentVersion: String(currentManagerVersion || ''),
+      currentClientVersion: String(currentClientVersion || ''),
+      latestVersion: latestRelease?.latestManagerVersion || '',
+      latestClientVersion: latestRelease?.latestClientVersion || '',
+      updateAvailable,
+      managerUpdateAvailable,
+      clientUpdateAvailable,
+      clientPackageUpdateAvailable,
+      outdatedClientCount: outdatedClientDevices.length,
+      checkedAt: latestRelease?.checkedAt || '',
+      checkError,
+      restartSupported: !!restartSupported,
+      canApply: updateAvailable && (!managerUpdateAvailable && !clientPackageUpdateAvailable || !!restartSupported),
+      ...(activeRun || { state: 'idle', operationId: '', targetCount: 0, completedCount: 0, waitingCount: 0, failedCount: 0, targets: [] })
+    };
+  };
+
+  const failRun = (message) => {
+    if (!run) return;
+    run.state = 'failed';
+    run.error = String(message || 'LiveDesk update failed.');
+    touch();
+    if (runTimer) {
+      clearInterval(runTimer);
+      runTimer = null;
+    }
+  };
+
+  const requestRestart = () => {
+    if (!restartSupported) {
+      failRun('Hub launcher restart is unavailable. Start LiveDesk through npx livedesk@latest.');
+      return false;
+    }
+    const result = requestHubRestart?.({
+      operationId: run?.operationId || '',
+      latestVersion: latestRelease?.latestManagerVersion || '',
+      latestClientVersion: latestRelease?.latestClientVersion || '',
+      // Current versions update every connected Client before the Hub exits.
+      // Older Hub versions did the reverse and set this flag themselves; the
+      // new server still supports that one-time migration path.
+      continueClientUpdate: false
+    });
+    if (result?.ok !== true) {
+      failRun(result?.error || 'Hub launcher restart request failed.');
+      return false;
+    }
+    if (run) {
+      run.state = 'hub-restart-requested';
+      touch();
+    }
+    return true;
+  };
+
+  const verifyTargets = () => {
+    if (!run || run.state !== 'waiting-for-clients') return;
+    const devices = new Map(connectedDevices(remoteHub).map(device => [String(device.deviceId), device]));
+    for (const target of run.targets) {
+      if (target.state === 'failed' || target.state === 'completed') continue;
+      const device = devices.get(target.deviceId);
+      if (device?.connected === true && isVersionAtLeast(device.agentVersion, run.latestClientVersion)) {
+        target.state = 'completed';
+        target.currentVersion = String(device.agentVersion || '');
+        target.completedAt = new Date(now()).toISOString();
+      } else {
+        target.state = 'waiting';
+      }
+    }
+    touch();
+    if (run.targets.every(target => target.state === 'completed')) {
+      if (runTimer) {
+        clearInterval(runTimer);
+        runTimer = null;
+      }
+      if (run.needsHubRestart) {
+        requestRestart();
+      } else {
+        run.state = 'clients-updated';
+        touch();
+      }
+      return;
+    }
+    if (now() - Date.parse(run.startedAt) >= LIVE_DESK_UPDATE_TIMEOUT_MS) {
+      failRun(`Timed out waiting for ${run.targets.filter(target => target.state !== 'completed').length} client(s) to reconnect with ${run.latestClientVersion}.`);
+    }
+  };
+
+  const dispatchTarget = (target, credentials) => {
+    const device = target.device;
+    const supportsDedicated = device.capabilities?.clientUpdate === true
+      && isVersionAtLeast(device.agentVersion, LIVE_DESK_DEDICATED_CLIENT_UPDATE_MIN_VERSION);
+    const payload = {
+      targetVersion: run.latestClientVersion,
+      managerVersion: run.latestManagerVersion,
+      operationId: run.operationId
+    };
+    const result = supportsDedicated
+      ? remoteHub.sendCommand(device.deviceId, { command: LIVE_DESK_UPDATE_COMMAND, payload })
+      : remoteHub.sendLegacyClientUpdate(device.deviceId, {
+        command: buildLegacyUpdateCommand(device, credentials, run.latestClientVersion),
+        timeoutMs: 30_000
+      });
+    if (result?.ok !== true) {
+      target.state = 'failed';
+      target.error = String(result?.error || 'client-update-dispatch-failed');
+      return false;
+    }
+    target.state = 'waiting';
+    target.method = supportsDedicated ? 'dedicated' : 'legacy-command-run';
+    target.commandId = String(result.commandId || result.taskId || '');
+    return true;
+  };
+
+  const startUpdate = async () => {
+    if (run && ['dispatching', 'waiting-for-clients', 'hub-restart-requested'].includes(run.state)) {
+      return { ok: true, ...getStatus() };
+    }
+    const release = latestRelease || await checkLatest();
+    if (!release) return { ok: false, error: checkError || 'LiveDesk update check failed.', ...getStatus() };
+    const managerNeedsUpdate = compareVersions(release.latestManagerVersion, currentManagerVersion) > 0;
+    const clientPackageNeedsUpdate = compareVersions(release.latestClientVersion, currentClientVersion) > 0;
+    const connected = connectedDevices(remoteHub);
+    const outdatedClients = connected.filter(device => !isVersionAtLeast(device.agentVersion, release.latestClientVersion));
+    const needsHubRestart = managerNeedsUpdate || clientPackageNeedsUpdate;
+    if (!managerNeedsUpdate && !clientPackageNeedsUpdate && outdatedClients.length === 0) {
+      return { ok: true, state: 'clients-updated', ...getStatus() };
+    }
+    if (needsHubRestart && !restartSupported) {
+      return { ok: false, error: 'Hub launcher restart is unavailable. Start LiveDesk through npx livedesk@latest.', ...getStatus() };
+    }
+    const targets = outdatedClients;
+    const credentials = remoteHub.getStatus({ includeSecrets: true });
+    run = {
+      operationId: randomUUID(),
+      state: 'dispatching',
+      startedAt: new Date(now()).toISOString(),
+      updatedAt: new Date(now()).toISOString(),
+      latestManagerVersion: release.latestManagerVersion,
+      latestClientVersion: release.latestClientVersion,
+      needsHubRestart,
+      error: '',
+      targets: targets.map(device => ({
+        deviceId: String(device.deviceId || ''),
+        deviceName: String(device.deviceName || device.hostname || device.deviceId || ''),
+        oldVersion: String(device.agentVersion || ''),
+        currentVersion: '',
+        state: 'queued',
+        method: '',
+        commandId: '',
+        error: '',
+        device
+      }))
+    };
+    for (const target of run.targets) dispatchTarget(target, credentials);
+    run.targets = run.targets.map(({ device, ...target }) => target);
+    touch();
+    if (run.targets.some(target => target.state === 'failed')) {
+      failRun('One or more clients could not be scheduled for update.');
+      return { ok: false, error: run.error, ...getStatus() };
+    }
+    if (run.targets.length === 0) {
+      if (run.needsHubRestart) {
+        requestRestart();
+      } else {
+        run.state = 'clients-updated';
+        touch();
+      }
+      return { ok: true, ...getStatus() };
+    }
+    run.state = 'waiting-for-clients';
+    runTimer = setInterval(verifyTargets, 1000);
+    runTimer.unref?.();
+    verifyTargets();
+    return { ok: true, ...getStatus() };
+  };
+
+  const handleRemoteEvent = (type, event) => {
+    if (!run || run.state !== 'waiting-for-clients' || type !== 'RemoteCommandResult') return;
+    const deviceId = String(event?.device?.deviceId || '');
+    const commandId = String(event?.commandId || '');
+    const target = run.targets.find(item => item.deviceId === deviceId && item.commandId === commandId);
+    if (!target || !['dedicated', 'legacy-command-run'].includes(target.method)) return;
+    const result = event?.result;
+    if (event?.error || result?.ok === false || result?.status === 'failed' || result?.status === 'rejected') {
+      target.state = 'failed';
+      target.error = String(event.error || result?.error || result?.message || 'client-update-command-failed').slice(0, 500);
+      touch();
+      failRun(target.method === 'dedicated'
+        ? `Client ${target.deviceName || target.deviceId} rejected the update request: ${target.error}`
+        : `Client ${target.deviceName || target.deviceId} failed the update command: ${target.error}`);
+    }
+  };
+
+  checkTimer = setInterval(() => { void checkLatest(); }, LIVE_DESK_UPDATE_CHECK_INTERVAL_MS);
+  checkTimer.unref?.();
+  void checkLatest();
+
+  return {
+    checkLatest,
+    getStatus,
+    startUpdate,
+    handleRemoteEvent,
+    close() {
+      if (checkTimer) clearInterval(checkTimer);
+      if (runTimer) clearInterval(runTimer);
+      checkTimer = null;
+      runTimer = null;
+    }
+  };
+}

package/src/mode4-atlas.js

@@ -10,6 +10,8 @@ export class Mode4AtlasSession {
     this.onStatus = typeof options.onStatus === 'function' ? options.onStatus : () => {};
     this.deviceIds = [];
     this.deviceSet = new Set();
+    this.inputDeviceIds = [];
+    this.inputDeviceSet = new Set();
     this.config = null;
     this.closed = false;
     this.worker = null;
@@ -65,7 +67,10 @@ export class Mode4AtlasSession {
     this.deviceIds = [...new Set((Array.isArray(options.deviceIds) ? options.deviceIds : [])
       .map(value => String(value || '').trim()).filter(Boolean))].slice(0, 100);
     this.deviceSet = new Set(this.deviceIds);
-    this.pendingFrames = new Map([...this.pendingFrames].filter(([deviceId]) => this.deviceSet.has(deviceId)));
+    this.inputDeviceIds = [...new Set((Array.isArray(options.inputDeviceIds) ? options.inputDeviceIds : this.deviceIds)
+      .map(value => String(value || '').trim()).filter(value => this.deviceSet.has(value)))].slice(0, 100);
+    this.inputDeviceSet = new Set(this.inputDeviceIds);
+    this.pendingFrames = new Map([...this.pendingFrames].filter(([deviceId]) => this.inputDeviceSet.has(deviceId)));
     this.config = {
       deviceIds: this.deviceIds,
       width: Number(options.width || 1920),
@@ -102,7 +107,7 @@ export class Mode4AtlasSession {
     const frame = frameEvent?.frame || {};
     const deviceId = String(frameEvent?.deviceId || frame.deviceId || '').trim();
     const mode = String(frame.frameMode || frame.mode || '').toLowerCase();
-    if (!this.deviceSet.has(deviceId) || mode !== 'mode2-lzo' || !Buffer.isBuffer(frameEvent?.payload)) return;
+    if (!this.inputDeviceSet.has(deviceId) || mode !== 'mode2-lzo' || !Buffer.isBuffer(frameEvent?.payload)) return;
     this.pendingFrames.set(deviceId, {
       type: 'frame',
       deviceId,