livedesk 0.1.261 → 0.1.263

package/bin/livedesk.js

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFile, spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import os from 'node:os';
 
@@ -17,7 +17,8 @@ const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_MANAGER_URL = `http://127.0.0.1:${DEFAULT_MANAGER_HTTP_PORT}`;
 const PORT_CLEANUP_TIMEOUT_MS = 3000;
 const PORT_CLEANUP_POLL_MS = 100;
-const HUB_STARTUP_RETRY_LIMIT = 1;
+const HUB_STARTUP_RETRY_LIMIT = 1;
+const HUB_UPDATE_POLL_MS = 250;
 const MANAGER_STATE_DIR = join(os.homedir(), '.livedesk');
 const MANAGER_STATE_PATH = join(MANAGER_STATE_DIR, 'manager.json');
 
@@ -75,13 +76,21 @@ Common options:
 `.trimStart());
 }
 
-function readVersion() {
+function readVersion() {
   try {
     return require('../package.json').version || '0.0.0';
   } catch {
     return '0.0.0';
   }
-}
+}
+
+function readClientVersion() {
+  try {
+    return require('../package.json').dependencies?.['@livedesk/client'] || '';
+  } catch {
+    return '';
+  }
+}
 
 function parseManagerArgs(args) {
   const forwarded = [];
@@ -501,7 +510,7 @@ function resolvePackageEntry(packageName, fallback) {
   }
 }
 
-async function runManager(args) {
+async function runManager(args) {
   const options = parseManagerArgs(args);
   const httpPort = normalizePort(
     options.port || process.env.LIVEDESK_HUB_HTTP_PORT || process.env.PORT,
@@ -514,10 +523,13 @@ async function runManager(args) {
   const openUrl = options.openUrlExplicit
     ? (options.openUrl || `http://127.0.0.1:${httpPort}`)
     : `http://127.0.0.1:${httpPort}`;
-  const pairToken = process.env.REMOTE_HUB_PAIR_TOKEN
-    || process.env.LIVEDESK_CLIENT_PAIR_TOKEN
-    || process.env.MINDEXEC_REMOTE_PAIR_TOKEN
-    || getStablePairToken();
+  const pairToken = process.env.REMOTE_HUB_PAIR_TOKEN
+    || process.env.LIVEDESK_CLIENT_PAIR_TOKEN
+    || process.env.MINDEXEC_REMOTE_PAIR_TOKEN
+    || getStablePairToken();
+  mkdirSync(MANAGER_STATE_DIR, { recursive: true });
+  const updateRequestPath = join(MANAGER_STATE_DIR, `hub-update-${httpPort}-${remotePort}.json`);
+  rmSync(updateRequestPath, { force: true });
 
   if (options.cleanPortsOnStart) {
     await stopProcessesOnPorts([httpPort, remotePort]);
@@ -531,21 +543,61 @@ async function runManager(args) {
   const env = {
     ...process.env,
     LIVEDESK_HUB_HTTP_HOST: options.host || process.env.LIVEDESK_HUB_HTTP_HOST || '127.0.0.1',
-    LIVEDESK_HUB_HTTP_PORT: String(httpPort),
-    LIVEDESK_MANAGER_VERSION: readVersion(),
+    LIVEDESK_HUB_HTTP_PORT: String(httpPort),
+    LIVEDESK_MANAGER_VERSION: readVersion(),
+    LIVEDESK_CLIENT_PACKAGE_VERSION: readClientVersion(),
+    LIVEDESK_HUB_UPDATE_REQUEST_PATH: updateRequestPath,
     REMOTE_HUB_PORT: String(remotePort),
     REMOTE_HUB_PAIR_TOKEN: pairToken,
     LIVEDESK_WEB_DIST: existsSync(resolve(packagedWebDist, 'index.html')) ? packagedWebDist : (process.env.LIVEDESK_WEB_DIST || '')
   };
 
-  let startupRetryCount = 0;
-  const startHubProcess = () => {
+  let startupRetryCount = 0;
+  let restartRequested = false;
+  let activeChild = null;
+  let updatePollId = null;
+
+  const restartWithLatest = () => {
+    const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const next = spawn(npxCommand, ['-y', '--prefer-online', 'livedesk@latest', 'hub', ...args], {
+      env: process.env,
+      stdio: 'inherit',
+      detached: true,
+      windowsHide: false
+    });
+    next.once('error', error => {
+      console.error(`Failed to relaunch LiveDesk Hub from npm: ${error.message}`);
+    });
+    next.unref();
+    console.log('[LiveDesk Hub] Update approved. The latest Hub launcher is starting.');
+    setTimeout(() => process.exit(0), 100);
+  };
+
+  const pollUpdateRequest = () => {
+    if (!existsSync(updateRequestPath)) return;
+    try {
+      const request = JSON.parse(readFileSync(updateRequestPath, 'utf8'));
+      rmSync(updateRequestPath, { force: true });
+      if (request?.pid && Number(request.pid) !== Number(activeChild?.pid || 0)) {
+        restartRequested = true;
+        console.log(`[LiveDesk Hub] Restart requested for update ${request.operationId || 'unknown'}.`);
+        if (activeChild && !activeChild.killed) {
+          activeChild.kill('SIGTERM');
+        }
+      }
+    } catch {
+      // The Hub writes the request atomically; a partial/stale file is retried.
+    }
+  };
+
+  const startHubProcess = () => {
     const stderrChunks = [];
-    const child = spawn(process.execPath, [hubEntry, ...options.forwarded], {
+    const child = spawn(process.execPath, [hubEntry, ...options.forwarded], {
       env,
       stdio: ['inherit', 'inherit', 'pipe'],
       windowsHide: false
-    });
+    });
+    activeChild = child;
 
     child.stderr.on('data', chunk => {
       const text = chunk.toString();
@@ -560,8 +612,17 @@ async function runManager(args) {
       console.error(`Failed to start LiveDesk Hub: ${error.message}`);
       process.exitCode = 1;
     });
-    child.once('exit', (code, signal) => {
-      const startupOutput = stderrChunks.join('');
+    child.once('exit', (code, signal) => {
+      const startupOutput = stderrChunks.join('');
+      if (restartRequested) {
+        restartRequested = false;
+        if (updatePollId) {
+          clearInterval(updatePollId);
+          updatePollId = null;
+        }
+        restartWithLatest();
+        return;
+      }
       if (!signal
         && code !== 0
         && options.cleanPortsOnStart
@@ -585,10 +646,11 @@ async function runManager(args) {
     });
   };
 
-  startHubProcess();
+  startHubProcess();
+  updatePollId = setInterval(pollUpdateRequest, HUB_UPDATE_POLL_MS);
 
   if (options.openBrowserOnStart) {
-    void waitForManager(openUrl).then(ok => {
+    void waitForManager(openUrl).then(ok => {
       if (ok) {
         openBrowser(openUrl);
       } else {

package/hub/src/live-desk-update.js

@@ -0,0 +1,411 @@
+import { randomUUID } from 'node:crypto';
+
+export const LIVE_DESK_UPDATE_COMMAND = 'livedesk.client-update';
+export const LIVE_DESK_UPDATE_TIMEOUT_MS = 120_000;
+export const LIVE_DESK_UPDATE_CHECK_INTERVAL_MS = 5 * 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',
+    '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)}`,
+    '$npx = (Get-Command npx.cmd -ErrorAction SilentlyContinue).Source',
+    'if (-not $npx) { $npx = "npx.cmd" }',
+    'Start-Process -FilePath $npx -ArgumentList @("-y", "--prefer-online", "livedesk@latest", "client", "--no-login", "--update-wait-pid", [string]$launcherPid) -WindowStyle Hidden',
+    'Start-Sleep -Milliseconds 500',
+    '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 buildUnixLegacyUpdateCommand({ manager, pair, name, slot, targetVersion }) {
+  const script = [
+    'const { execFileSync, spawn } = require("node:child_process");',
+    'const fs = require("node:fs");',
+    'const os = require("node:os");',
+    'const path = require("node:path");',
+    'const self = process.pid;',
+    '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 ""; } };',
+    'let cursor = parentOf(self); let launcherPid = 0;',
+    'for (let depth = 0; depth < 12 && cursor; depth++) { const command = commandOf(cursor); if (/livedesk-client\\.js|livedesk\\.js/i.test(command)) { launcherPid = cursor; break; } cursor = parentOf(cursor); }',
+    'if (!launcherPid) throw new Error("LiveDesk client launcher process was not found.");',
+    `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 updater = spawn("npx", ["-y", "--prefer-online", "livedesk@latest", "client", "--no-login", "--update-wait-pid", String(launcherPid)], { detached: true, stdio: "ignore" });',
+    'updater.unref();',
+    'setTimeout(() => { try { process.kill(launcherPid, "SIGTERM"); } catch {} }, 500);',
+    ''
+  ].join('\n');
+  return `node -e ${JSON.stringify(script)}`;
+}
+
+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 || ''
+    });
+    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;
+    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.requestAgentTask(device.deviceId, {
+        operation: 'command.run',
+        title: 'Update LiveDesk client',
+        instruction: 'Update and restart this LiveDesk client.',
+        toolArguments: {
+          command: buildLegacyUpdateCommand(device, credentials, run.latestClientVersion),
+          timeoutMs: 30_000
+        },
+        permissionMode: 'full-access',
+        approvalLevel: 'once'
+      });
+    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: false, error: 'LiveDesk is already up to date.', ...getStatus() };
+    }
+    if (needsHubRestart && !restartSupported) {
+      return { ok: false, error: 'Hub launcher restart is unavailable. Start LiveDesk through npx livedesk@latest.', ...getStatus() };
+    }
+    const targets = managerNeedsUpdate || clientPackageNeedsUpdate ? connected : 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 || target.method !== 'dedicated') return;
+    const result = event?.result;
+    if (event?.error || result?.ok === false || result?.status === 'failed') {
+      target.state = 'failed';
+      target.error = String(event.error || result?.error || 'client-update-command-failed');
+      touch();
+      failRun('A client rejected the update request. Hub was kept running.');
+    }
+  };
+
+  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/hub/src/remote-hub.js

@@ -4490,15 +4490,17 @@ export function createRemoteHub(options = {}) {
     function sendCommand(deviceId, command) {
         const device = devices.get(String(deviceId || ''));
         const commandName = safeString(command?.command || 'ping', 80);
-        const requiredPermission = commandName === 'input.control'
-            ? 'allowControl'
-            : commandName.startsWith('file.transfer')
-                ? 'allowFileTransfer'
-                : commandName === 'audio.start'
-                    ? 'allowRemoteAudio'
-                    : commandName.startsWith('agent.')
-                        ? 'allowAgent'
-                        : '';
+        const requiredPermission = commandName === 'input.control'
+            ? 'allowControl'
+            : commandName.startsWith('file.transfer')
+                ? 'allowFileTransfer'
+                : commandName === 'audio.start'
+                    ? 'allowRemoteAudio'
+                    : commandName === 'livedesk.client-update'
+                        ? 'allowAgent'
+                    : commandName.startsWith('agent.')
+                        ? 'allowAgent'
+                        : '';
         const denied = policyError(device, requiredPermission);
         if (denied) return { ok: false, error: denied };
         if (device?.synthetic === true && device.connected) {