@livedesk/client 0.1.214 → 0.1.216

package/bin/livedesk-client-node.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import net from 'net';
 import os from 'os';
@@ -7,259 +7,263 @@ import crypto from 'crypto';
 import { existsSync, promises as fs, statfsSync } from 'fs';
 import { spawn } from 'child_process';
 import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
-const AGENT_VERSION = (() => {
+const CLIENT_UPDATE_BOOTSTRAP_PATH = fileURLToPath(
+    new URL('./livedesk-client-update-bootstrap.cjs', import.meta.url)
+);
+const AGENT_VERSION = (() => {
     try {
         return String(require('../package.json').version || '0.0.0');
     } catch {
         return '0.0.0';
-    }
-})();
-const PRODUCT_VERSION = String(process.env.LIVEDESK_NPM_LAUNCHER_VERSION || AGENT_VERSION).trim() || AGENT_VERSION;
-const DEFAULT_MANAGER = '127.0.0.1:5197';
+    }
+})();
+const PRODUCT_VERSION = String(process.env.LIVEDESK_NPM_LAUNCHER_VERSION || AGENT_VERSION).trim() || AGENT_VERSION;
+const DEFAULT_MANAGER = '127.0.0.1:5197';
 const DEFAULT_HEARTBEAT_MS = 5000;
-const DEFAULT_RECONNECT_MS = 5000;
-const EXIT_INVALID_PAIR_TOKEN = 23;
-const EXIT_CLIENT_UPDATE = 42;
-const DEFAULT_LIVE_FPS = 30;
-const MAX_LIVE_FPS = 30;
-const MAX_FRAME_BASE64_CHARS = 3 * 1024 * 1024;
-const MAX_FILE_TRANSFER_FILES = 24;
+const DEFAULT_RECONNECT_MS = 5000;
+const EXIT_INVALID_PAIR_TOKEN = 23;
+const EXIT_CLIENT_UPDATE = 42;
+const DEFAULT_LIVE_FPS = 30;
+const MAX_LIVE_FPS = 30;
+const MAX_FRAME_BASE64_CHARS = 3 * 1024 * 1024;
+const MAX_FILE_TRANSFER_FILES = 24;
 const MAX_FILE_TRANSFER_BYTES = 24 * 1024 * 1024;
 const MAX_AGENT_OUTPUT_CHARS = 32000;
-const launchedProcessRegistry = new Map();
-const CLIENT_UPDATE_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-
-function normalizeClientUpdateTargetVersion(value) {
-    const version = String(value || '').trim().replace(/^v/i, '');
-    if (!version) return '';
-    if (!CLIENT_UPDATE_VERSION_PATTERN.test(version)) {
-        throw new Error(`Invalid LiveDesk product update version: ${version}`);
-    }
-    return version;
-}
-
-function getClientUpdateStatePath() {
-    return path.resolve(
-        String(process.env.LIVEDESK_CLIENT_UPDATE_STATE_PATH || path.join(os.homedir(), '.livedesk', 'client-update.json'))
-    );
-}
-
-function getClientUpdateNeutralCwd(operationId) {
-    const safeOperationId = String(operationId || '')
-        .replace(/[^A-Za-z0-9._-]/g, '_')
-        .slice(0, 120) || 'unknown';
-    return path.join(os.tmpdir(), 'livedesk-update-cwd', `client-${safeOperationId}`);
-}
-
-async function prepareClientUpdateNeutralCwd(operationId) {
-    const neutralCwd = path.resolve(getClientUpdateNeutralCwd(operationId));
-    await fs.mkdir(neutralCwd, { recursive: true });
-    const unexpectedEntry = (await fs.readdir(neutralCwd))[0];
-    if (unexpectedEntry) {
-        const shadowPath = path.join(neutralCwd, unexpectedEntry);
-        throw new Error(`LiveDesk update neutral working directory is shadowed by ${shadowPath}: ${neutralCwd}`);
-    }
-    return neutralCwd;
-}
-
-function buildClientUpdateNpxEnvironment(baseEnv, neutralCwd) {
-    const env = { ...baseEnv };
-    const isolatedNames = new Set([
-        'init_cwd',
-        'npm_config_local_prefix',
-        'npm_config_workspace',
-        'npm_config_workspaces',
-        'npm_config_include_workspace_root',
-        'npm_package_json',
-        'npm_lifecycle_event',
-        'npm_lifecycle_script'
-    ]);
-    for (const key of Object.keys(env)) {
-        if (isolatedNames.has(key.toLowerCase())) delete env[key];
-    }
-    env.INIT_CWD = neutralCwd;
-    env.npm_config_local_prefix = neutralCwd;
-    env.npm_config_workspaces = 'false';
-    env.npm_config_include_workspace_root = 'false';
-    return env;
-}
-
-function isClientUpdatePidAlive(value) {
-    const pid = Number(value);
-    if (!Number.isInteger(pid) || pid <= 1) return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    } catch (error) {
-        return error?.code === 'EPERM';
-    }
-}
-
-function canReclaimClientUpdateOperation(previous) {
-    const handoffOwners = [
-        previous?.supervisorPid,
-        previous?.starterPid
-    ].map(Number).filter(pid => Number.isInteger(pid) && pid > 1);
-    if (handoffOwners.length > 0) {
-        return handoffOwners.every(pid => !isClientUpdatePidAlive(pid));
-    }
-    if (String(previous?.stage || '') === 'scheduled') {
-        const schedulingOwners = [
-            previous?.agentPid,
-            previous?.launcherPid
-        ].map(Number).filter(pid => Number.isInteger(pid) && pid > 1);
-        return schedulingOwners.length > 0
-            && schedulingOwners.every(pid => !isClientUpdatePidAlive(pid));
-    }
-    return false;
-}
-
-async function writeClientUpdateState(stage, details = {}) {
-    const statePath = getClientUpdateStatePath();
-    const operationId = String(details.operationId || process.env.LIVEDESK_CLIENT_UPDATE_OPERATION_ID || '').trim();
-    if (!operationId) return;
-    const attemptId = stage === 'scheduled'
-        ? ''
-        : String(details.attemptId || process.env.LIVEDESK_CLIENT_UPDATE_ATTEMPT_ID || '').trim();
-    let previous = null;
-    try {
-        previous = JSON.parse(await fs.readFile(statePath, 'utf8'));
-    } catch {
-        // The first update stage creates the file.
-    }
-    const replacesTerminalOperation = previous?.operationId
-        && previous.operationId !== operationId
-        && stage === 'scheduled'
-        && ['connected', 'failed', 'restored'].includes(String(previous.stage || ''));
-    const reclaimsDeadOperation = previous?.operationId
-        && previous.operationId !== operationId
-        && stage === 'scheduled'
-        && canReclaimClientUpdateOperation(previous);
-    const replacesPreviousOperation = replacesTerminalOperation || reclaimsDeadOperation;
-    if (previous?.operationId && previous.operationId !== operationId && !replacesPreviousOperation) return;
-    if (!replacesPreviousOperation
-        && previous?.attemptId
-        && attemptId
-        && previous.attemptId !== attemptId) {
-        return;
-    }
-    if (!replacesPreviousOperation
-        && previous?.stage === 'connected'
-        && previous?.restartVerified === true
-        && stage !== 'connected') {
-        return;
-    }
-    const targetProductVersion = String(
-        details.targetProductVersion
-        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION
-        || (!replacesPreviousOperation ? previous?.targetProductVersion : '')
-        || ''
-    ).trim();
-    const targetAgentVersion = String(
-        details.targetAgentVersion
-        || details.targetVersion
-        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION
-        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
-        || (!replacesPreviousOperation ? previous?.targetAgentVersion : '')
-        || (!replacesPreviousOperation ? previous?.targetVersion : '')
-        || ''
-    ).trim();
-    const state = {
-        ...(!replacesPreviousOperation && previous && typeof previous === 'object' ? previous : {}),
-        operationId,
-        stage,
-        targetVersion: targetAgentVersion,
-        targetProductVersion,
-        targetAgentVersion,
-        productVersion: PRODUCT_VERSION,
-        agentVersion: AGENT_VERSION,
-        agentPid: process.pid,
-        launcherPid: Number(process.env.LIVEDESK_CLIENT_PARENT_PID || 0) || 0,
-        attemptId,
-        updatedAt: new Date().toISOString(),
-        ...details
-    };
-    await fs.mkdir(path.dirname(statePath), { recursive: true });
-    const temporaryPath = `${statePath}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
-    try {
-        await fs.writeFile(temporaryPath, JSON.stringify(state, null, 2), { encoding: 'utf8', mode: 0o600 });
-        let current = null;
-        try {
-            current = JSON.parse(await fs.readFile(statePath, 'utf8'));
-        } catch {
-            // A missing first-write state is still owned by this transition.
-        }
-        if (String(current?.operationId || '') !== String(previous?.operationId || '')
-            || String(current?.stage || '') !== String(previous?.stage || '')
-            || String(current?.updatedAt || '') !== String(previous?.updatedAt || '')) {
-            return;
-        }
-        await fs.rename(temporaryPath, statePath);
-    } finally {
-        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
-    }
-}
-
-async function waitForClientUpdateShutdownSignal(
-    operationId,
-    updateDeadlineEpochMs,
-    timeoutMs = 180_000
-) {
-    const statePath = getClientUpdateStatePath();
-    const deadline = Math.min(
-        Date.now() + timeoutMs,
-        Number(updateDeadlineEpochMs) || 0
-    );
-    while (Date.now() < deadline) {
-        try {
-            const state = JSON.parse(await fs.readFile(statePath, 'utf8'));
-            if (state?.operationId !== operationId) {
-                await wait(200);
-                continue;
-            }
-            if (state.stage === 'preflight-ready' || state.stage === 'waiting-for-shutdown') {
-                return { ready: true, error: '' };
-            }
-            if (state.stage === 'failed') {
-                const error = String(state.error || 'LiveDesk client update preparation failed.');
-                console.error(`LiveDesk client update preparation failed: ${error}`);
-                return { ready: false, error };
-            }
-        } catch {
-            // The detached supervisor may still be writing its first stage.
-        }
-        await wait(200);
-    }
-    const deadlineExpired = Date.now() >= Number(updateDeadlineEpochMs);
-    const error = deadlineExpired
-        ? 'The absolute LiveDesk Client update deadline expired before shutdown.'
-        : 'Timed out waiting for the LiveDesk update supervisor to prepare the exact package.';
-    await writeClientUpdateState('failed', {
-        operationId,
-        error,
-        cancelRequested: true,
-        deadlineExpired,
-        failedAt: new Date().toISOString()
-    }).catch(() => undefined);
-    console.error('LiveDesk client update preparation timed out; the current Agent will remain running.');
-    return { ready: false, error };
-}
-
-function markClientUpdateConnected() {
-    const operationId = String(process.env.LIVEDESK_CLIENT_UPDATE_OPERATION_ID || '').trim();
-    if (!operationId) return;
-    void writeClientUpdateState('connected', {
-        operationId,
-        attemptId: String(process.env.LIVEDESK_CLIENT_UPDATE_ATTEMPT_ID || '').trim(),
-        connectedAt: new Date().toISOString(),
-        restartVerified: true,
-        error: ''
-    }).catch(error => {
-        console.error(`LiveDesk client update diagnostics could not be persisted: ${error?.message || error}`);
-    });
-}
+const launchedProcessRegistry = new Map();
+const CLIENT_UPDATE_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+function normalizeClientUpdateTargetVersion(value) {
+    const version = String(value || '').trim().replace(/^v/i, '');
+    if (!version) return '';
+    if (!CLIENT_UPDATE_VERSION_PATTERN.test(version)) {
+        throw new Error(`Invalid LiveDesk product update version: ${version}`);
+    }
+    return version;
+}
+
+function getClientUpdateStatePath() {
+    return path.resolve(
+        String(process.env.LIVEDESK_CLIENT_UPDATE_STATE_PATH || path.join(os.homedir(), '.livedesk', 'client-update.json'))
+    );
+}
+
+function getClientUpdateNeutralCwd(operationId) {
+    const safeOperationId = String(operationId || '')
+        .replace(/[^A-Za-z0-9._-]/g, '_')
+        .slice(0, 120) || 'unknown';
+    return path.join(os.tmpdir(), 'livedesk-update-cwd', `client-${safeOperationId}`);
+}
+
+async function prepareClientUpdateNeutralCwd(operationId) {
+    const neutralCwd = path.resolve(getClientUpdateNeutralCwd(operationId));
+    await fs.mkdir(neutralCwd, { recursive: true });
+    const unexpectedEntry = (await fs.readdir(neutralCwd))[0];
+    if (unexpectedEntry) {
+        const shadowPath = path.join(neutralCwd, unexpectedEntry);
+        throw new Error(`LiveDesk update neutral working directory is shadowed by ${shadowPath}: ${neutralCwd}`);
+    }
+    return neutralCwd;
+}
+
+function buildClientUpdateNpxEnvironment(baseEnv, neutralCwd) {
+    const env = { ...baseEnv };
+    const isolatedNames = new Set([
+        'init_cwd',
+        'npm_config_local_prefix',
+        'npm_config_workspace',
+        'npm_config_workspaces',
+        'npm_config_include_workspace_root',
+        'npm_package_json',
+        'npm_lifecycle_event',
+        'npm_lifecycle_script'
+    ]);
+    for (const key of Object.keys(env)) {
+        if (isolatedNames.has(key.toLowerCase())) delete env[key];
+    }
+    env.INIT_CWD = neutralCwd;
+    env.npm_config_local_prefix = neutralCwd;
+    env.npm_config_workspaces = 'false';
+    env.npm_config_include_workspace_root = 'false';
+    return env;
+}
+
+function isClientUpdatePidAlive(value) {
+    const pid = Number(value);
+    if (!Number.isInteger(pid) || pid <= 1) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
+function canReclaimClientUpdateOperation(previous) {
+    const handoffOwners = [
+        previous?.supervisorPid,
+        previous?.starterPid
+    ].map(Number).filter(pid => Number.isInteger(pid) && pid > 1);
+    if (handoffOwners.length > 0) {
+        return handoffOwners.every(pid => !isClientUpdatePidAlive(pid));
+    }
+    if (String(previous?.stage || '') === 'scheduled') {
+        const schedulingOwners = [
+            previous?.agentPid,
+            previous?.launcherPid
+        ].map(Number).filter(pid => Number.isInteger(pid) && pid > 1);
+        return schedulingOwners.length > 0
+            && schedulingOwners.every(pid => !isClientUpdatePidAlive(pid));
+    }
+    return false;
+}
+
+async function writeClientUpdateState(stage, details = {}) {
+    const statePath = getClientUpdateStatePath();
+    const operationId = String(details.operationId || process.env.LIVEDESK_CLIENT_UPDATE_OPERATION_ID || '').trim();
+    if (!operationId) return;
+    const attemptId = stage === 'scheduled'
+        ? ''
+        : String(details.attemptId || process.env.LIVEDESK_CLIENT_UPDATE_ATTEMPT_ID || '').trim();
+    let previous = null;
+    try {
+        previous = JSON.parse(await fs.readFile(statePath, 'utf8'));
+    } catch {
+        // The first update stage creates the file.
+    }
+    const replacesTerminalOperation = previous?.operationId
+        && previous.operationId !== operationId
+        && stage === 'scheduled'
+        && ['connected', 'failed', 'restored'].includes(String(previous.stage || ''));
+    const reclaimsDeadOperation = previous?.operationId
+        && previous.operationId !== operationId
+        && stage === 'scheduled'
+        && canReclaimClientUpdateOperation(previous);
+    const replacesPreviousOperation = replacesTerminalOperation || reclaimsDeadOperation;
+    if (previous?.operationId && previous.operationId !== operationId && !replacesPreviousOperation) return;
+    if (!replacesPreviousOperation
+        && previous?.attemptId
+        && attemptId
+        && previous.attemptId !== attemptId) {
+        return;
+    }
+    if (!replacesPreviousOperation
+        && previous?.stage === 'connected'
+        && previous?.restartVerified === true
+        && stage !== 'connected') {
+        return;
+    }
+    const targetProductVersion = String(
+        details.targetProductVersion
+        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION
+        || (!replacesPreviousOperation ? previous?.targetProductVersion : '')
+        || ''
+    ).trim();
+    const targetAgentVersion = String(
+        details.targetAgentVersion
+        || details.targetVersion
+        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION
+        || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
+        || (!replacesPreviousOperation ? previous?.targetAgentVersion : '')
+        || (!replacesPreviousOperation ? previous?.targetVersion : '')
+        || ''
+    ).trim();
+    const state = {
+        ...(!replacesPreviousOperation && previous && typeof previous === 'object' ? previous : {}),
+        operationId,
+        stage,
+        targetVersion: targetAgentVersion,
+        targetProductVersion,
+        targetAgentVersion,
+        productVersion: PRODUCT_VERSION,
+        agentVersion: AGENT_VERSION,
+        agentPid: process.pid,
+        launcherPid: Number(process.env.LIVEDESK_CLIENT_PARENT_PID || 0) || 0,
+        attemptId,
+        updatedAt: new Date().toISOString(),
+        ...details
+    };
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    const temporaryPath = `${statePath}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+    try {
+        await fs.writeFile(temporaryPath, JSON.stringify(state, null, 2), { encoding: 'utf8', mode: 0o600 });
+        let current = null;
+        try {
+            current = JSON.parse(await fs.readFile(statePath, 'utf8'));
+        } catch {
+            // A missing first-write state is still owned by this transition.
+        }
+        if (String(current?.operationId || '') !== String(previous?.operationId || '')
+            || String(current?.stage || '') !== String(previous?.stage || '')
+            || String(current?.updatedAt || '') !== String(previous?.updatedAt || '')) {
+            return;
+        }
+        await fs.rename(temporaryPath, statePath);
+    } finally {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
+
+async function waitForClientUpdateShutdownSignal(
+    operationId,
+    updateDeadlineEpochMs,
+    timeoutMs = 180_000
+) {
+    const statePath = getClientUpdateStatePath();
+    const deadline = Math.min(
+        Date.now() + timeoutMs,
+        Number(updateDeadlineEpochMs) || 0
+    );
+    while (Date.now() < deadline) {
+        try {
+            const state = JSON.parse(await fs.readFile(statePath, 'utf8'));
+            if (state?.operationId !== operationId) {
+                await wait(200);
+                continue;
+            }
+            if (state.stage === 'preflight-ready' || state.stage === 'waiting-for-shutdown') {
+                return { ready: true, error: '' };
+            }
+            if (state.stage === 'failed') {
+                const error = String(state.error || 'LiveDesk client update preparation failed.');
+                console.error(`LiveDesk client update preparation failed: ${error}`);
+                return { ready: false, error };
+            }
+        } catch {
+            // The detached supervisor may still be writing its first stage.
+        }
+        await wait(200);
+    }
+    const deadlineExpired = Date.now() >= Number(updateDeadlineEpochMs);
+    const error = deadlineExpired
+        ? 'The absolute LiveDesk Client update deadline expired before shutdown.'
+        : 'Timed out waiting for the LiveDesk update supervisor to prepare the exact package.';
+    await writeClientUpdateState('failed', {
+        operationId,
+        error,
+        cancelRequested: true,
+        deadlineExpired,
+        failedAt: new Date().toISOString()
+    }).catch(() => undefined);
+    console.error('LiveDesk client update preparation timed out; the current Agent will remain running.');
+    return { ready: false, error };
+}
+
+function markClientUpdateConnected() {
+    const operationId = String(process.env.LIVEDESK_CLIENT_UPDATE_OPERATION_ID || '').trim();
+    if (!operationId) return;
+    void writeClientUpdateState('connected', {
+        operationId,
+        attemptId: String(process.env.LIVEDESK_CLIENT_UPDATE_ATTEMPT_ID || '').trim(),
+        connectedAt: new Date().toISOString(),
+        restartVerified: true,
+        error: ''
+    }).catch(error => {
+        console.error(`LiveDesk client update diagnostics could not be persisted: ${error?.message || error}`);
+    });
+}
 
 function printHelp() {
     console.log(`
@@ -279,10 +283,10 @@ Options:
   --no-thumbnail         Disable thumbnail capture capability.
   --live                 Enable focused live screen streaming. Default on.
   --no-live              Disable focused live screen streaming.
-  --tasks                Enable safe remote task inbox. Default on.
-  --no-tasks             Disable remote task dispatch capability.
-  --files-dir <path>     Default folder for received files. Default: ~/Desktop/LiveDeskFiles.
-  --fake-thumbnail       Use generated thumbnail frames for smoke tests.
+  --tasks                Enable safe remote task inbox. Default on.
+  --no-tasks             Disable remote task dispatch capability.
+  --files-dir <path>     Default folder for received files. Default: ~/Desktop/LiveDeskFiles.
+  --fake-thumbnail       Use generated thumbnail frames for smoke tests.
   --exit-on-disconnect   Exit after Hub disconnect. Useful for tests.
   --exit-on-invalid-pair Exit when the Hub rejects the pair token.
   --once                 Connect, send one status packet, and exit after welcome.
@@ -322,10 +326,10 @@ function parseArgs(argv) {
         heartbeatMs: DEFAULT_HEARTBEAT_MS,
         deviceId: '',
         thumbnailEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_THUMBNAIL ?? process.env.MINDEXEC_REMOTE_THUMBNAIL),
-        liveEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_LIVE ?? process.env.MINDEXEC_REMOTE_LIVE),
-        taskEnabled: !isFalsy(process.env.LIVEDESK_CLIENT_TASKS ?? process.env.MINDEXEC_REMOTE_TASKS),
-        filesDir: process.env.LIVEDESK_CLIENT_FILES_DIR || process.env.MINDEXEC_REMOTE_FILES_DIR || '',
-        fakeThumbnail: isTruthy(process.env.LIVEDESK_CLIENT_FAKE_THUMBNAIL || process.env.MINDEXEC_REMOTE_FAKE_THUMBNAIL),
+        liveEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_LIVE ?? process.env.MINDEXEC_REMOTE_LIVE),
+        taskEnabled: !isFalsy(process.env.LIVEDESK_CLIENT_TASKS ?? process.env.MINDEXEC_REMOTE_TASKS),
+        filesDir: process.env.LIVEDESK_CLIENT_FILES_DIR || process.env.MINDEXEC_REMOTE_FILES_DIR || '',
+        fakeThumbnail: isTruthy(process.env.LIVEDESK_CLIENT_FAKE_THUMBNAIL || process.env.MINDEXEC_REMOTE_FAKE_THUMBNAIL),
         exitOnDisconnect: false,
         exitOnInvalidPair: false,
         once: false,
@@ -377,11 +381,11 @@ function parseArgs(argv) {
             case '--no-tasks':
                 result.taskEnabled = false;
                 break;
-            case '--files-dir':
-                result.filesDir = args[++index] || result.filesDir;
-                break;
-            case '--fake-thumbnail':
-                result.fakeThumbnail = true;
+            case '--files-dir':
+                result.filesDir = args[++index] || result.filesDir;
+                break;
+            case '--fake-thumbnail':
+                result.fakeThumbnail = true;
                 result.thumbnailEnabled = true;
                 break;
             case '--exit-on-disconnect':
@@ -561,7 +565,7 @@ function getStatus(options = {}) {
         usedMemRatio,
         platform: os.platform(),
         release: os.release(),
-        role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
+        role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
         cpu: {
             cores: cpuCores,
             model: cpus[0]?.model || '',
@@ -584,9 +588,9 @@ function getStatus(options = {}) {
         gpu: acceleratorStatus.gpu,
         npu: acceleratorStatus.npu,
         network: getNetworkStatus(),
-        workload: {
-            role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
-            status: 'idle',
+        workload: {
+            role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
+            status: 'idle',
             title: 'idle'
         },
         timestamp: new Date().toISOString()
@@ -916,17 +920,17 @@ async function captureThumbnailFrame(options, payload, frameSeq) {
     return await captureScreenFrame(options, payload, frameSeq, 'thumbnail');
 }
 
-const RETIRED_CLIENT_AGENT_TASK_ERROR = 'agent-ai-assist-retired';
-
-function getRetiredClientAgentTaskError(payload = {}) {
-    const source = payload && typeof payload === 'object' ? payload : {};
-    const approvalLevel = String(source.approvalLevel || '').trim().toLowerCase();
-    const hasModelSelection = ['model', 'aiModel', 'aiProvider', 'provider']
-        .some(key => Object.prototype.hasOwnProperty.call(source, key));
-    return approvalLevel === 'ai-assist' || hasModelSelection
-        ? RETIRED_CLIENT_AGENT_TASK_ERROR
-        : '';
-}
+const RETIRED_CLIENT_AGENT_TASK_ERROR = 'agent-ai-assist-retired';
+
+function getRetiredClientAgentTaskError(payload = {}) {
+    const source = payload && typeof payload === 'object' ? payload : {};
+    const approvalLevel = String(source.approvalLevel || '').trim().toLowerCase();
+    const hasModelSelection = ['model', 'aiModel', 'aiProvider', 'provider']
+        .some(key => Object.prototype.hasOwnProperty.call(source, key));
+    return approvalLevel === 'ai-assist' || hasModelSelection
+        ? RETIRED_CLIENT_AGENT_TASK_ERROR
+        : '';
+}
 
 function clampInteger(value, min, max, fallback) {
     const number = Number(value);
@@ -1372,15 +1376,15 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
                 restart: { executable: 'shutdown.exe', args: ['/r', '/t', delaySec] },
                 shutdown: { executable: 'shutdown.exe', args: ['/s', '/t', delaySec] }
             }[action] || {});
-        } else if (process.platform === 'darwin') {
-            ({ executable, args: powerArgs } = {
-                lock: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to keystroke "q" using {control down, command down}'] },
-                sleep: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to sleep'] },
-                logoff: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to log out'] },
-                restart: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to restart'] },
-                shutdown: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to shut down'] }
-            }[action] || {});
-        } else {
+        } else if (process.platform === 'darwin') {
+            ({ executable, args: powerArgs } = {
+                lock: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to keystroke "q" using {control down, command down}'] },
+                sleep: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to sleep'] },
+                logoff: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to log out'] },
+                restart: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to restart'] },
+                shutdown: { executable: '/usr/bin/osascript', args: ['-e', 'tell application "System Events" to shut down'] }
+            }[action] || {});
+        } else {
             ({ executable, args: powerArgs } = {
                 lock: { executable: 'loginctl', args: ['lock-session'] },
                 sleep: { executable: 'systemctl', args: ['suspend'] },
@@ -1432,11 +1436,11 @@ function remotePolicyAllows(options, command) {
     const policy = options.effectivePolicy;
     if (!policy || typeof policy !== 'object') return { ok: true };
     if (policy.accessMode === 'block-remote-access') return { ok: false, error: 'remote-access-blocked-by-settings' };
-    const required = command === 'input.control'
-        ? ['allowControl']
-        : command === 'system.power'
-            ? ['allowPowerActions']
-        : command.startsWith('file.transfer')
+    const required = command === 'input.control'
+        ? ['allowControl']
+        : command === 'system.power'
+            ? ['allowPowerActions']
+        : command.startsWith('file.transfer')
             ? ['allowFileTransfer']
             : command === 'audio.start'
                 ? ['allowRemoteAudio']
@@ -1449,192 +1453,139 @@ function remotePolicyAllows(options, command) {
     return denied ? { ok: false, error: `${denied}-blocked-by-settings` } : { ok: true };
 }
 
-function buildClientUpdateBootstrapScript() {
-    return [
-        'const { execFile, spawn } = require("node:child_process");',
-        'const fs = require("node:fs");',
-        'const path = require("node:path");',
-        'const operationId = String(process.env.LIVEDESK_CLIENT_UPDATE_OPERATION_ID || "").trim();',
-        'const originalCwd = path.resolve(String(process.env.LIVEDESK_UPDATE_ORIGINAL_CWD || process.cwd()));',
-        'const statePath = path.resolve(originalCwd, String(process.env.LIVEDESK_CLIENT_UPDATE_STATE_PATH || path.join(require("node:os").homedir(), ".livedesk", "client-update.json")));',
-        'const neutralCwdValue = String(process.env.LIVEDESK_UPDATE_NEUTRAL_CWD || "").trim();',
-        'const neutralCwd = neutralCwdValue ? path.resolve(neutralCwdValue) : "";',
-        'const cleanVersion = value => String(value || "").trim().replace(/^v/i, "");',
-        'const targetProductVersion = cleanVersion(process.env.LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION);',
-        'const updateDeadlineEpochMs = Number(process.env.LIVEDESK_CLIENT_UPDATE_DEADLINE_EPOCH_MS || 0);',
-        'const deadlineExpired = () => !Number.isSafeInteger(updateDeadlineEpochMs) || Date.now() >= updateDeadlineEpochMs;',
-        'const versionPattern = /^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$/;',
-        'const readState = () => { try { return JSON.parse(fs.readFileSync(statePath, "utf8")); } catch { return {}; } };',
-        'const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));',
-        'const isAlive = pid => { try { process.kill(pid, 0); return true; } catch (error) { return error?.code === "EPERM"; } };',
-        'const isGroupAlive = pid => { try { process.kill(-pid, 0); return true; } catch (error) { return error?.code === "EPERM"; } };',
-        'const runWindowsPowerShell = script => new Promise((resolve, reject) => { execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], { windowsHide: true, timeout: 15000, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => { if (error) { reject(new Error(String(stderr || error.message || "PowerShell failed").trim())); return; } resolve(String(stdout || "").trim()); }); });',
-        'const queryWindowsProcessTable = async () => { const stdout = await runWindowsPowerShell(`$ErrorActionPreference = "Stop"; $records = @(Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate | ForEach-Object { $ticks = if ($_.CreationDate) { [string]$_.CreationDate.ToUniversalTime().Ticks } else { "" }; [pscustomobject]@{ ProcessId = [int]$_.ProcessId; ParentProcessId = [int]$_.ParentProcessId; CreationUtcTicks = $ticks } }); [pscustomobject]@{ Records = $records } | ConvertTo-Json -Compress -Depth 4`); if (!stdout) throw new Error("Windows process snapshot returned no data"); const parsed = JSON.parse(stdout); const values = parsed?.Records == null ? [] : (Array.isArray(parsed.Records) ? parsed.Records : [parsed.Records]); return values.map(item => ({ pid: Number(item?.ProcessId || 0), parentPid: Number(item?.ParentProcessId || 0), startOrder: String(item?.CreationUtcTicks || "") })).filter(item => Number.isInteger(item.pid) && item.pid > 1 && /^\\d+$/.test(item.startOrder)); };',
-        'const queryTrackedWindowsProcessTable = child => { if (child.livedeskWindowsSnapshotPromise) return child.livedeskWindowsSnapshotPromise; const pending = queryWindowsProcessTable(); child.livedeskWindowsSnapshotPromise = pending; const clear = () => { if (child.livedeskWindowsSnapshotPromise === pending) child.livedeskWindowsSnapshotPromise = null; }; pending.then(clear, clear); return pending; };',
-        'const sameWindowsIdentity = (left, right) => Number(left?.pid || 0) === Number(right?.pid || 0) && String(left?.startOrder || "") === String(right?.startOrder || "");',
-        'const captureWindowsIdentity = async child => { const processId = Number(child?.pid || 0); const deadline = Date.now() + 2500; let lastError = null; do { try { const snapshot = await queryTrackedWindowsProcessTable(child); const identity = snapshot.find(item => item.pid === processId) || null; if (identity) return identity; } catch (error) { lastError = error; } if (Date.now() < deadline) await sleep(50); } while (Date.now() < deadline); throw new Error(`Could not capture immutable Windows CreationDate for pid=${processId}: ${lastError?.message || "process not visible"}`); };',
-        'const windowsTicksAtMilliseconds = value => BigInt(Math.trunc(Number(value) || Date.now())) * 10000n + 621355968000000000n;',
-        'const setWindowsRootLifetimeEnd = (child, ticks) => { const candidate = BigInt(ticks); const previous = child.livedeskWindowsRootLifetimeEndTicks; if (!previous || candidate < BigInt(previous)) child.livedeskWindowsRootLifetimeEndTicks = String(candidate); return BigInt(child.livedeskWindowsRootLifetimeEndTicks); };',
-        'const mergeRootAbsentWindowsTree = (child, rootPid, snapshot) => { const tracked = child.livedeskWindowsTrackedRecords || (child.livedeskWindowsTrackedRecords = new Map()); const currentByPid = new Map(snapshot.map(item => [item.pid, item])); const exactCurrentByPid = new Map(); for (const record of tracked.values()) { const current = currentByPid.get(record.pid); if (sameWindowsIdentity(current, record)) exactCurrentByPid.set(record.pid, record); } const lowerBound = windowsTicksAtMilliseconds(Number(child.livedeskWindowsSpawnedAtMs || Date.now()) - 2000); const upperBound = child.livedeskWindowsRootLifetimeEndTicks ? BigInt(child.livedeskWindowsRootLifetimeEndTicks) : null; let changed = true; while (changed) { changed = false; for (const record of snapshot) { const key = `${record.pid}:${record.startOrder}`; if (record.pid === rootPid || tracked.has(key)) continue; let recordStart; try { recordStart = BigInt(record.startOrder); if (recordStart < lowerBound || (upperBound && recordStart > upperBound)) continue; } catch { continue; } const parent = record.parentPid === rootPid ? { depth: 0 } : exactCurrentByPid.get(record.parentPid); if (!parent) continue; const descendant = { ...record, depth: Number(parent.depth || 0) + 1 }; tracked.set(key, descendant); exactCurrentByPid.set(descendant.pid, descendant); changed = true; } } return tracked; };',
-        'const mergeExactWindowsTree = (child, root, snapshot) => { const tracked = child.livedeskWindowsTrackedRecords || (child.livedeskWindowsTrackedRecords = new Map()); const currentByPid = new Map(snapshot.map(item => [item.pid, item])); const currentRoot = currentByPid.get(root.pid) || null; const rootIsExact = sameWindowsIdentity(currentRoot, root); const rootWasReused = Boolean(currentRoot && !rootIsExact); if (rootWasReused) setWindowsRootLifetimeEnd(child, BigInt(currentRoot.startOrder) - 1n); else if (!currentRoot && child.livedeskWindowsRootExitedAtMs) setWindowsRootLifetimeEnd(child, windowsTicksAtMilliseconds(child.livedeskWindowsRootExitedAtMs)); const rootLifetimeClosed = Boolean(child.livedeskWindowsRootLifetimeEndTicks); if (rootIsExact) tracked.set(`${root.pid}:${root.startOrder}`, { ...root, depth: 0 }); const exactCurrentByPid = new Map(); if (rootIsExact) exactCurrentByPid.set(root.pid, { ...root, depth: 0 }); for (const record of tracked.values()) { const current = currentByPid.get(record.pid); if (sameWindowsIdentity(current, record)) exactCurrentByPid.set(record.pid, record); } let changed = true; while (changed) { changed = false; for (const record of snapshot) { const key = `${record.pid}:${record.startOrder}`; if (record.pid === root.pid || tracked.has(key)) continue; let recordStart; try { recordStart = BigInt(record.startOrder); if (recordStart < BigInt(root.startOrder)) continue; if (rootLifetimeClosed && recordStart > BigInt(child.livedeskWindowsRootLifetimeEndTicks)) continue; } catch { continue; } let parent = exactCurrentByPid.get(record.parentPid) || null; if (!parent && !currentRoot && rootLifetimeClosed && record.parentPid === root.pid) parent = { ...root, depth: 0 }; if (!parent) continue; const descendant = { ...record, depth: Number(parent.depth || 0) + 1 }; tracked.set(key, descendant); exactCurrentByPid.set(descendant.pid, descendant); changed = true; } } return tracked; };',
-        'const refreshTrackedWindowsTree = async (child, root = child.livedeskWindowsIdentity || null) => { const snapshot = await queryTrackedWindowsProcessTable(child); if (root) mergeExactWindowsTree(child, root, snapshot); else mergeRootAbsentWindowsTree(child, Number(child.pid || 0), snapshot); return snapshot; };',
-        'const stopExactWindowsRecords = async records => { if (!Array.isArray(records) || records.length === 0) return; const encoded = Buffer.from(JSON.stringify(records.map(record => ({ pid: record.pid, startOrder: record.startOrder }))), "utf8").toString("base64"); const script = `$ErrorActionPreference = "Stop"; $targetsJson = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("${encoded}")); $targets = ConvertFrom-Json -InputObject $targetsJson; $failures = [System.Collections.Generic.List[string]]::new(); foreach ($item in $targets) { $targetPid = [int]$item.pid; $expectedStartTicks = [string]$item.startOrder; try { $target = Get-CimInstance Win32_Process -Filter "ProcessId = $targetPid" -Property ProcessId,CreationDate -ErrorAction SilentlyContinue | Select-Object -First 1; if (-not $target) { continue }; $targetStartTicks = if ($target.CreationDate) { [string]$target.CreationDate.ToUniversalTime().Ticks } else { "" }; if ($targetStartTicks -ne $expectedStartTicks) { continue }; Stop-Process -Id $targetPid -Force -ErrorAction Stop } catch { $failures.Add("pid=$targetPid $($_.Exception.Message)") } }; if ($failures.Count -gt 0) { [Console]::Error.WriteLine(($failures -join "; ")); exit 1 }`; await runWindowsPowerShell(script); };',
-        'const trackWindowsChild = child => { if (process.platform !== "win32" || Number(child?.pid || 0) <= 1 || child.livedeskWindowsIdentityPromise) return; child.livedeskWindowsTrackedRecords = new Map(); child.livedeskWindowsSpawnedAtMs = Date.now(); child.livedeskWindowsRootExitedAtMs = null; child.livedeskWindowsTrackingStopped = false; child.once("exit", () => { if (!child.livedeskWindowsRootExitedAtMs) child.livedeskWindowsRootExitedAtMs = Date.now(); setWindowsRootLifetimeEnd(child, windowsTicksAtMilliseconds(child.livedeskWindowsRootExitedAtMs)); }); const refresh = () => { void refreshTrackedWindowsTree(child).then(() => { child.livedeskWindowsTrackingError = null; }).catch(error => { child.livedeskWindowsTrackingError = error; }); }; refresh(); child.livedeskWindowsTrackingTimer = setInterval(refresh, 250); child.livedeskWindowsTrackingTimer.unref?.(); child.livedeskWindowsIdentityPromise = (async () => { while (!child.livedeskWindowsTrackingStopped && !child.livedeskWindowsRootExitedAtMs) { try { const identity = await captureWindowsIdentity(child); child.livedeskWindowsIdentity = identity; refresh(); return identity; } catch (error) { child.livedeskWindowsIdentityError = error; if (!child.livedeskWindowsTrackingStopped && !child.livedeskWindowsRootExitedAtMs) await sleep(250); } } return null; })(); };',
-        'const stopWindowsTracking = child => { child.livedeskWindowsTrackingStopped = true; if (child?.livedeskWindowsTrackingTimer) clearInterval(child.livedeskWindowsTrackingTimer); child.livedeskWindowsTrackingTimer = null; };',
-        'const terminateExactWindowsTrackedTree = (child, root) => { if (child.livedeskWindowsDrainPromise) return child.livedeskWindowsDrainPromise; child.livedeskWindowsDrainPromise = (async () => { let attempt = 0; let emptyPasses = 0; for (;;) { attempt += 1; try { const snapshot = await refreshTrackedWindowsTree(child, root); const currentByPid = new Map(snapshot.map(item => [item.pid, item])); const remaining = [...child.livedeskWindowsTrackedRecords.values()].filter(target => sameWindowsIdentity(currentByPid.get(target.pid), target)).sort((left, right) => Number(right.depth || 0) - Number(left.depth || 0)); if (remaining.length === 0) { emptyPasses += 1; if (emptyPasses >= 2) { stopWindowsTracking(child); return; } } else { emptyPasses = 0; await stopExactWindowsRecords(remaining); } child.livedeskWindowsTrackingError = null; } catch (error) { emptyPasses = 0; child.livedeskWindowsTrackingError = error; if (attempt === 1 || attempt % 10 === 0) process.stderr.write(`LiveDesk update cleanup is retrying exact Windows process-tree drain: ${error?.message || error}\\n`); } await sleep(Math.min(1000, 100 + (attempt * 50))); } })(); return child.livedeskWindowsDrainPromise; };',
-        'const stateLockPath = statePath + ".lock"; const lockWaitBuffer = new Int32Array(new SharedArrayBuffer(4));',
-        'const waitForStateLock = ms => Atomics.wait(lockWaitBuffer, 0, 0, Math.max(1, ms));',
-        'const removeAbandonedStateLock = () => { let owner = null; try { owner = JSON.parse(fs.readFileSync(stateLockPath, "utf8")); } catch {} const ownerPid = Number(owner?.pid || 0); if (Number.isInteger(ownerPid) && ownerPid > 1) { if (isAlive(ownerPid)) return false; } else { try { if (Date.now() - fs.statSync(stateLockPath).mtimeMs < 5000) return false; } catch { return true; } } try { fs.rmSync(stateLockPath); return true; } catch { return false; } };',
-        'const withStateLock = callback => { fs.mkdirSync(path.dirname(stateLockPath), { recursive: true }); const deadline = Date.now() + 10000; let descriptor = null; let token = ""; while (descriptor === null) { try { descriptor = fs.openSync(stateLockPath, "wx", 0o600); token = process.pid + "-" + Date.now() + "-" + Math.random().toString(16).slice(2); fs.writeFileSync(descriptor, JSON.stringify({ pid: process.pid, token, acquiredAt: new Date().toISOString() }), "utf8"); } catch (error) { if (descriptor !== null) { try { fs.closeSync(descriptor); } catch {} descriptor = null; try { fs.rmSync(stateLockPath, { force: true }); } catch {} } if (error?.code !== "EEXIST") throw error; if (removeAbandonedStateLock()) continue; if (Date.now() >= deadline) throw new Error("Timed out waiting for the LiveDesk update state lock: " + stateLockPath); waitForStateLock(Math.min(25, Math.max(1, deadline - Date.now()))); } } try { return callback(); } finally { try { fs.closeSync(descriptor); } catch {} try { const owner = JSON.parse(fs.readFileSync(stateLockPath, "utf8")); if (owner?.token === token && Number(owner?.pid) === process.pid) fs.rmSync(stateLockPath, { force: true }); } catch {} } };',
-        'const writeFailure = (error, cancelRequested = false) => { try { withStateLock(() => { const previous = readState(); if (previous.operationId && previous.operationId !== operationId) return; if (previous.stage === "preflight-ready" || previous.stage === "waiting-for-shutdown" || previous.stage === "connected" || previous.stage === "restored") return; const now = new Date().toISOString(); const next = { ...previous, operationId, stage: "failed", targetProductVersion, restartVerified: false, cancelRequested: cancelRequested || previous.cancelRequested === true, error: String(error?.message || error).slice(0, 4000), failedAt: now, updatedAt: now }; const temporary = statePath + "." + process.pid + ".handoff.tmp"; fs.writeFileSync(temporary, JSON.stringify(next, null, 2), { encoding: "utf8", mode: 0o600 }); fs.renameSync(temporary, statePath); }); } catch {} process.stderr.write("LiveDesk update handoff failed: " + (error?.message || error) + "\\n"); process.exitCode = 1; };',
-        'const writeCancellation = error => withStateLock(() => { const previous = readState(); if (previous.operationId && previous.operationId !== operationId) return "superseded"; if (previous.operationId !== operationId) return false; if (previous.stage === "preflight-ready" || previous.stage === "waiting-for-shutdown") return "ready"; if (previous.stage === "failed") return previous.cancelRequested === true ? "cancelled" : "failed"; const now = new Date().toISOString(); const next = { ...previous, operationId, stage: "failed", targetProductVersion, restartVerified: false, cancelRequested: true, error: String(error?.message || error).slice(0, 4000), cancelledAt: now, failedAt: now, updatedAt: now }; const temporary = statePath + "." + process.pid + ".cancel.tmp"; fs.writeFileSync(temporary, JSON.stringify(next, null, 2), { encoding: "utf8", mode: 0o600 }); fs.renameSync(temporary, statePath); return "cancelled"; });',
-        'const terminateTree = async child => { const pid = Number(child?.pid || 0); if (pid <= 1) return; if (process.platform === "win32") { const root = child.livedeskWindowsIdentity || await child.livedeskWindowsIdentityPromise; if (!root && !child.livedeskWindowsRootExitedAtMs) { child.livedeskWindowsTrackingError = child.livedeskWindowsIdentityError || new Error(`No immutable Windows identity is available for pid=${pid}`); while (!child.livedeskWindowsRootExitedAtMs && !child.livedeskWindowsIdentity) await sleep(250); } await terminateExactWindowsTrackedTree(child, child.livedeskWindowsIdentity || root || null); return; } try { process.kill(-pid, "SIGTERM"); } catch { try { child.kill("SIGTERM"); } catch {} } const gracefulDeadline = Date.now() + 2000; while (Date.now() < gracefulDeadline && (isGroupAlive(pid) || isAlive(pid))) await sleep(100); if (isGroupAlive(pid) || isAlive(pid)) { try { process.kill(-pid, "SIGKILL"); } catch { try { child.kill("SIGKILL"); } catch {} } } };',
-        'const writeHandoffStarted = () => withStateLock(() => { if (deadlineExpired()) throw new Error("The absolute LiveDesk Client update deadline expired before handoff."); const previous = readState(); if (previous.operationId !== operationId) throw new Error("LiveDesk update handoff was superseded before exact-package launch."); const now = new Date().toISOString(); const next = { ...previous, operationId, stage: "handoff-started", starterPid: process.pid, updateDeadlineEpochMs, restartVerified: false, error: "", updatedAt: now }; const temporary = statePath + "." + process.pid + ".handoff-started.tmp"; fs.writeFileSync(temporary, JSON.stringify(next, null, 2), { encoding: "utf8", mode: 0o600 }); fs.renameSync(temporary, statePath); });',
-        'const monitorPreflight = child => { let settled = false; let draining = false; let drainPromise = null; const finish = (error, preserveFailure = false) => { if (settled) return; settled = true; clearInterval(poll); clearTimeout(timeout); stopWindowsTracking(child); child.unref(); if (preserveFailure) process.exitCode = 1; else if (error) writeFailure(error); }; const drainAndFinish = (error, preserveFailure = false) => { if (settled) return Promise.resolve(); draining = true; if (!drainPromise) drainPromise = terminateTree(child).then(() => finish(error, preserveFailure)); return drainPromise; }; const inspect = () => { if (draining) return; const state = readState(); if (state.operationId !== operationId) return; if (state.stage === "preflight-ready" || state.stage === "waiting-for-shutdown") finish(); else if (state.stage === "failed") void drainAndFinish(null, true); }; const cancelTimedOutHandoff = async () => { const error = new Error(deadlineExpired() ? "The absolute LiveDesk Client update deadline expired before exact-package preflight." : "Timed out waiting for exact-package update preflight."); draining = true; while (!settled) { let outcome; try { outcome = writeCancellation(error); } catch (lockError) { await drainAndFinish(lockError); return; } if (outcome === "ready") { draining = false; inspect(); return; } if (outcome === "failed" || outcome === "cancelled" || outcome === "superseded") { await drainAndFinish(null, true); return; } await sleep(25); } }; const poll = setInterval(inspect, 100); const timeoutMs = Math.max(1, Math.min(Math.max(1000, Number(process.env.LIVEDESK_CLIENT_UPDATE_HANDOFF_TIMEOUT_MS || 140000)), updateDeadlineEpochMs - Date.now())); const timeout = setTimeout(() => { void cancelTimedOutHandoff().catch(error => { void drainAndFinish(error); }); }, timeoutMs); child.once("exit", (code, signal) => { inspect(); if (settled || draining) return; const error = new Error("Exact-package update supervisor exited before preflight (code=" + (code ?? "none") + ", signal=" + (signal || "none") + ")."); void drainAndFinish(error); }); inspect(); };',
-        'const prepareNeutralCwd = () => { if (!neutralCwd) throw new Error("LiveDesk update neutral working directory is unavailable"); fs.mkdirSync(neutralCwd, { recursive: true }); const unexpectedEntry = fs.readdirSync(neutralCwd)[0]; if (unexpectedEntry) { const shadow = path.join(neutralCwd, unexpectedEntry); throw new Error("LiveDesk update neutral working directory is shadowed by " + shadow + ": " + neutralCwd); } };',
-        'if (!operationId || !versionPattern.test(targetProductVersion) || deadlineExpired()) { writeFailure(new Error("Invalid or expired LiveDesk exact-package update handoff."), true); } else { try { prepareNeutralCwd(); writeHandoffStarted();',
-        'const env = { ...process.env, LIVEDESK_UPDATE_STARTER_PID: String(process.pid) }; const isolated = new Set(["init_cwd", "npm_config_local_prefix", "npm_config_workspace", "npm_config_workspaces", "npm_config_include_workspace_root", "npm_package_json", "npm_lifecycle_event", "npm_lifecycle_script"]); for (const key of Object.keys(env)) if (isolated.has(key.toLowerCase())) delete env[key]; env.INIT_CWD = neutralCwd; env.npm_config_local_prefix = neutralCwd; env.npm_config_workspaces = "false"; env.npm_config_include_workspace_root = "false";',
-        'const nodeDir = path.dirname(process.execPath);',
-        'const npxCli = [env.LIVEDESK_NPX_CLI_PATH, env.npm_execpath ? path.join(path.dirname(env.npm_execpath), "npx-cli.js") : "", env.LIVEDESK_NPX_EXECUTABLE ? path.join(path.dirname(env.LIVEDESK_NPX_EXECUTABLE), "node_modules", "npm", "bin", "npx-cli.js") : "", path.join(nodeDir, "node_modules", "npm", "bin", "npx-cli.js")].find(value => value && fs.existsSync(value));',
-        'const npx = env.LIVEDESK_NPX_EXECUTABLE || (process.platform === "win32" ? "npx.cmd" : "npx");',
-        'const args = ["-y", "--prefer-online", "--prefix", neutralCwd, "--workspaces=false", "livedesk@" + targetProductVersion, "--internal-legacy-client-update"];',
-        'const quoteCmd = value => "\\"" + String(value).replaceAll("%", "%%").replaceAll("\\"", "\\"\\"") + "\\"";',
-        'const invocation = npxCli ? { command: process.execPath, args: [npxCli, ...args] } : process.platform === "win32" ? { command: env.ComSpec || "cmd.exe", args: ["/d", "/s", "/c", "call " + quoteCmd(npx) + " " + args.map(quoteCmd).join(" ")] } : { command: npx, args };',
-        'if (!npxCli && path.isAbsolute(npx) && !fs.existsSync(npx)) { writeFailure(new Error("LiveDesk npx executable was not found: " + npx)); } else { try { const child = spawn(invocation.command, invocation.args, { cwd: neutralCwd, env, detached: true, stdio: "ignore", windowsHide: true }); trackWindowsChild(child); child.once("error", writeFailure); child.once("spawn", () => { trackWindowsChild(child); monitorPreflight(child); }); } catch (error) { writeFailure(error); } }',
-        '} catch (error) { writeFailure(error, deadlineExpired()); } }',
-        ''
-    ].join('\n');
-}
-
-async function scheduleClientUpdate(options, payload = {}) {
-    const operationId = String(payload.operationId || crypto.randomUUID()).trim();
-    const statePath = getClientUpdateStatePath();
-    let targetProductVersion = '';
-    let targetAgentVersion = '';
-    let updateDeadlineEpochMs = 0;
-    try {
-        targetProductVersion = normalizeClientUpdateTargetVersion(
-            payload.targetProductVersion
-            || payload.productVersion
-            || payload.managerVersion
-            || payload.targetVersion
-            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION
-            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
-            || ''
-        );
-        targetAgentVersion = normalizeClientUpdateTargetVersion(
-            payload.targetAgentVersion
-            || payload.clientVersion
-            || payload.targetVersion
-            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION
-            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
-            || targetProductVersion
-            || ''
-        );
-        const updateTimeoutMs = Number(payload.updateTimeoutMs);
-        if (!Number.isSafeInteger(updateTimeoutMs)
-            || updateTimeoutMs < 1_000
-            || updateTimeoutMs > 90 * 60_000) {
-            throw new Error('LiveDesk Client update requires a bounded deadline budget.');
-        }
-        updateDeadlineEpochMs = Date.now() + updateTimeoutMs;
-        const originalCwd = path.resolve(process.cwd());
-        const neutralCwd = await prepareClientUpdateNeutralCwd(operationId);
-        await writeClientUpdateState('scheduled', {
-            operationId,
-            targetVersion: targetAgentVersion,
-            targetProductVersion,
-            targetAgentVersion,
-            updateTimeoutMs,
-            updateDeadlineEpochMs,
-            requestedAt: new Date().toISOString(),
-            restartVerified: false,
-            error: ''
-        });
-        const configuredParentPid = Number(process.env.LIVEDESK_CLIENT_PARENT_PID || process.ppid);
-        const parentPid = Number.isInteger(configuredParentPid) && configuredParentPid > 1
-            ? configuredParentPid
-            : process.pid;
-        if (!Number.isInteger(parentPid) || parentPid <= 1) {
-            throw new Error('LiveDesk client launcher process id is unavailable.');
-        }
-        const nodeBinDir = path.dirname(process.execPath);
-        const npxCandidates = process.platform === 'win32'
-            ? [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeBinDir, 'npx.cmd'), path.join(nodeBinDir, 'npx.exe'), 'npx.cmd']
-            : [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeBinDir, 'npx'), 'npx'];
-        const command = npxCandidates.find(candidate => candidate && (!path.isAbsolute(candidate) || existsSync(candidate)));
-        if (!command) {
-            throw new Error('LiveDesk npx executable was not found.');
-        }
-        const frozenCommand = path.isAbsolute(command) || !/[\\/]/.test(command)
-            ? command
-            : path.resolve(originalCwd, command);
-        const configuredLocalLauncher = String(
-            process.env.LIVEDESK_UNIFIED_LAUNCHER_ENTRY
-            || process.env.LIVEDESK_CLIENT_UPDATE_LOCAL_LAUNCHER
-            || ''
-        ).trim();
-        const localLauncher = configuredLocalLauncher
-            ? path.resolve(originalCwd, configuredLocalLauncher)
-            : '';
-        const updateEnvironment = buildClientUpdateNpxEnvironment({
-            ...process.env,
-            LIVEDESK_NODE_EXECUTABLE: process.execPath,
-            LIVEDESK_NPX_EXECUTABLE: frozenCommand,
-            LIVEDESK_UPDATE_WAIT_PID: String(parentPid),
-            LIVEDESK_UPDATE_AGENT_PID: String(process.pid),
-            LIVEDESK_SKIP_BROWSER_OPEN: '1',
-            LIVEDESK_CLIENT_UPDATE_TARGET_VERSION: targetAgentVersion,
-            LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION: targetProductVersion,
-            LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION: targetAgentVersion,
-            LIVEDESK_CLIENT_UPDATE_CURRENT_PRODUCT_VERSION: PRODUCT_VERSION,
-            LIVEDESK_CLIENT_UPDATE_CURRENT_AGENT_VERSION: AGENT_VERSION,
-            LIVEDESK_CLIENT_UPDATE_LOCAL_LAUNCHER: localLauncher,
-            LIVEDESK_CLIENT_UPDATE_OPERATION_ID: operationId,
-            LIVEDESK_CLIENT_UPDATE_DEADLINE_EPOCH_MS: String(updateDeadlineEpochMs),
-            LIVEDESK_CLIENT_UPDATE_STATE_PATH: statePath,
-            LIVEDESK_UPDATE_NEUTRAL_CWD: neutralCwd,
-            LIVEDESK_UPDATE_ORIGINAL_CWD: originalCwd,
-            LIVEDESK_CLIENT_UPDATE_CWD: originalCwd
-        }, neutralCwd);
-        return await new Promise((resolve, reject) => {
-            const child = spawn(process.execPath, ['-e', buildClientUpdateBootstrapScript()], {
-                cwd: neutralCwd,
-                env: updateEnvironment,
-                detached: true,
-                stdio: 'ignore',
-                windowsHide: true
-            });
-            child.once('error', reject);
-            child.once('spawn', () => {
-                child.unref();
-                resolve({
-                    ok: true,
-                    status: 'update-scheduled',
-                    targetVersion: targetAgentVersion,
-                    targetProductVersion,
-                    targetAgentVersion,
-                    operationId,
-                    updateDeadlineEpochMs,
-                    statePath,
-                    parentPid,
-                    restartAfterMs: 0
-                });
-            });
-        });
-    } catch (error) {
-        await writeClientUpdateState('failed', {
-            operationId,
-            targetVersion: targetAgentVersion,
-            targetProductVersion,
-            targetAgentVersion,
-            error: error?.message || String(error),
-            failedAt: new Date().toISOString(),
-            restartVerified: false
-        }).catch(() => undefined);
-        throw error;
-    }
-}
+async function scheduleClientUpdate(options, payload = {}) {
+    const operationId = String(payload.operationId || crypto.randomUUID()).trim();
+    const statePath = getClientUpdateStatePath();
+    let targetProductVersion = '';
+    let targetAgentVersion = '';
+    let updateDeadlineEpochMs = 0;
+    try {
+        targetProductVersion = normalizeClientUpdateTargetVersion(
+            payload.targetProductVersion
+            || payload.productVersion
+            || payload.managerVersion
+            || payload.targetVersion
+            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION
+            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
+            || ''
+        );
+        targetAgentVersion = normalizeClientUpdateTargetVersion(
+            payload.targetAgentVersion
+            || payload.clientVersion
+            || payload.targetVersion
+            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION
+            || process.env.LIVEDESK_CLIENT_UPDATE_TARGET_VERSION
+            || targetProductVersion
+            || ''
+        );
+        const updateTimeoutMs = Number(payload.updateTimeoutMs);
+        if (!Number.isSafeInteger(updateTimeoutMs)
+            || updateTimeoutMs < 1_000
+            || updateTimeoutMs > 90 * 60_000) {
+            throw new Error('LiveDesk Client update requires a bounded deadline budget.');
+        }
+        updateDeadlineEpochMs = Date.now() + updateTimeoutMs;
+        const originalCwd = path.resolve(process.cwd());
+        const neutralCwd = await prepareClientUpdateNeutralCwd(operationId);
+        await writeClientUpdateState('scheduled', {
+            operationId,
+            targetVersion: targetAgentVersion,
+            targetProductVersion,
+            targetAgentVersion,
+            updateTimeoutMs,
+            updateDeadlineEpochMs,
+            requestedAt: new Date().toISOString(),
+            restartVerified: false,
+            error: ''
+        });
+        const configuredParentPid = Number(process.env.LIVEDESK_CLIENT_PARENT_PID || process.ppid);
+        const parentPid = Number.isInteger(configuredParentPid) && configuredParentPid > 1
+            ? configuredParentPid
+            : process.pid;
+        if (!Number.isInteger(parentPid) || parentPid <= 1) {
+            throw new Error('LiveDesk client launcher process id is unavailable.');
+        }
+        const nodeBinDir = path.dirname(process.execPath);
+        const npxCandidates = process.platform === 'win32'
+            ? [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeBinDir, 'npx.cmd'), path.join(nodeBinDir, 'npx.exe'), 'npx.cmd']
+            : [process.env.LIVEDESK_NPX_EXECUTABLE, path.join(nodeBinDir, 'npx'), 'npx'];
+        const command = npxCandidates.find(candidate => candidate && (!path.isAbsolute(candidate) || existsSync(candidate)));
+        if (!command) {
+            throw new Error('LiveDesk npx executable was not found.');
+        }
+        const frozenCommand = path.isAbsolute(command) || !/[\\/]/.test(command)
+            ? command
+            : path.resolve(originalCwd, command);
+        const configuredLocalLauncher = String(
+            process.env.LIVEDESK_UNIFIED_LAUNCHER_ENTRY
+            || process.env.LIVEDESK_CLIENT_UPDATE_LOCAL_LAUNCHER
+            || ''
+        ).trim();
+        const localLauncher = configuredLocalLauncher
+            ? path.resolve(originalCwd, configuredLocalLauncher)
+            : '';
+        const updateEnvironment = buildClientUpdateNpxEnvironment({
+            ...process.env,
+            LIVEDESK_NODE_EXECUTABLE: process.execPath,
+            LIVEDESK_NPX_EXECUTABLE: frozenCommand,
+            LIVEDESK_UPDATE_WAIT_PID: String(parentPid),
+            LIVEDESK_UPDATE_AGENT_PID: String(process.pid),
+            LIVEDESK_SKIP_BROWSER_OPEN: '1',
+            LIVEDESK_CLIENT_UPDATE_TARGET_VERSION: targetAgentVersion,
+            LIVEDESK_CLIENT_UPDATE_TARGET_PRODUCT_VERSION: targetProductVersion,
+            LIVEDESK_CLIENT_UPDATE_TARGET_AGENT_VERSION: targetAgentVersion,
+            LIVEDESK_CLIENT_UPDATE_CURRENT_PRODUCT_VERSION: PRODUCT_VERSION,
+            LIVEDESK_CLIENT_UPDATE_CURRENT_AGENT_VERSION: AGENT_VERSION,
+            LIVEDESK_CLIENT_UPDATE_LOCAL_LAUNCHER: localLauncher,
+            LIVEDESK_CLIENT_UPDATE_OPERATION_ID: operationId,
+            LIVEDESK_CLIENT_UPDATE_DEADLINE_EPOCH_MS: String(updateDeadlineEpochMs),
+            LIVEDESK_CLIENT_UPDATE_STATE_PATH: statePath,
+            LIVEDESK_UPDATE_NEUTRAL_CWD: neutralCwd,
+            LIVEDESK_UPDATE_ORIGINAL_CWD: originalCwd,
+            LIVEDESK_CLIENT_UPDATE_CWD: originalCwd
+        }, neutralCwd);
+        const bootstrapStat = await fs.stat(CLIENT_UPDATE_BOOTSTRAP_PATH);
+        if (!bootstrapStat.isFile() || bootstrapStat.size <= 0) {
+            throw new Error(`LiveDesk Client update bootstrap is unavailable: ${CLIENT_UPDATE_BOOTSTRAP_PATH}`);
+        }
+        return await new Promise((resolve, reject) => {
+            const child = spawn(process.execPath, [CLIENT_UPDATE_BOOTSTRAP_PATH], {
+                cwd: neutralCwd,
+                env: updateEnvironment,
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true
+            });
+            child.once('error', reject);
+            child.once('spawn', () => {
+                child.unref();
+                resolve({
+                    ok: true,
+                    status: 'update-scheduled',
+                    targetVersion: targetAgentVersion,
+                    targetProductVersion,
+                    targetAgentVersion,
+                    operationId,
+                    updateDeadlineEpochMs,
+                    statePath,
+                    parentPid,
+                    restartAfterMs: 0
+                });
+            });
+        });
+    } catch (error) {
+        await writeClientUpdateState('failed', {
+            operationId,
+            targetVersion: targetAgentVersion,
+            targetProductVersion,
+            targetAgentVersion,
+            error: error?.message || String(error),
+            failedAt: new Date().toISOString(),
+            restartVerified: false
+        }).catch(() => undefined);
+        throw error;
+    }
+}
 
 async function handleRemoteCommand(socket, options, message, nextFrameSeq, activeStreams) {
     const command = String(message.command || '');
@@ -1661,37 +1612,37 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
         return;
     }
 
-    if (command === 'livedesk.client-update') {
-        try {
-            const result = await scheduleClientUpdate(options, message.payload || {});
+    if (command === 'livedesk.client-update') {
+        try {
+            const result = await scheduleClientUpdate(options, message.payload || {});
             writeJsonLine(socket, {
                 type: 'command.result',
-                commandId: message.commandId,
-                result
-            });
-            const shutdownSignal = await waitForClientUpdateShutdownSignal(
-                result.operationId,
-                result.updateDeadlineEpochMs
-            );
-            if (shutdownSignal.ready) {
-                // The exact package supervisor is the sole owner of old-runtime
-                // termination, so a deadline can never race a voluntary exit.
-                return;
-            } else {
-                writeJsonLine(socket, {
-                    type: 'command.result',
-                    commandId: message.commandId,
-                    error: shutdownSignal.error,
-                    result: {
-                        ok: false,
-                        status: 'failed',
-                        error: shutdownSignal.error,
-                        operationId: result.operationId,
-                        completedAt: new Date().toISOString()
-                    }
-                });
-            }
-        } catch (error) {
+                commandId: message.commandId,
+                result
+            });
+            const shutdownSignal = await waitForClientUpdateShutdownSignal(
+                result.operationId,
+                result.updateDeadlineEpochMs
+            );
+            if (shutdownSignal.ready) {
+                // The exact package supervisor is the sole owner of old-runtime
+                // termination, so a deadline can never race a voluntary exit.
+                return;
+            } else {
+                writeJsonLine(socket, {
+                    type: 'command.result',
+                    commandId: message.commandId,
+                    error: shutdownSignal.error,
+                    result: {
+                        ok: false,
+                        status: 'failed',
+                        error: shutdownSignal.error,
+                        operationId: result.operationId,
+                        completedAt: new Date().toISOString()
+                    }
+                });
+            }
+        } catch (error) {
             writeJsonLine(socket, {
                 type: 'command.result',
                 commandId: message.commandId,
@@ -1745,25 +1696,25 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
                 error: 'remote task capability is disabled'
             });
             return;
-        }
-
-        const payload = message.payload || {};
-        const retiredTaskError = getRetiredClientAgentTaskError(payload);
-        if (retiredTaskError) {
-            writeJsonLine(socket, {
-                type: 'command.result',
-                commandId: message.commandId,
-                error: retiredTaskError,
-                result: {
-                    ok: false,
-                    status: 'failed',
-                    error: retiredTaskError,
-                    completedAt: new Date().toISOString()
-                }
-            });
-            return;
-        }
-        const instruction = String(payload.instruction || '').replace(/\0/g, '').trim().slice(0, 4000);
+        }
+
+        const payload = message.payload || {};
+        const retiredTaskError = getRetiredClientAgentTaskError(payload);
+        if (retiredTaskError) {
+            writeJsonLine(socket, {
+                type: 'command.result',
+                commandId: message.commandId,
+                error: retiredTaskError,
+                result: {
+                    ok: false,
+                    status: 'failed',
+                    error: retiredTaskError,
+                    completedAt: new Date().toISOString()
+                }
+            });
+            return;
+        }
+        const instruction = String(payload.instruction || '').replace(/\0/g, '').trim().slice(0, 4000);
         if (!instruction) {
             writeJsonLine(socket, {
                 type: 'command.result',
@@ -1773,13 +1724,13 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
             return;
         }
 
-        const completedAt = new Date().toISOString();
-        const title = String(payload.title || instruction.split(/\r?\n/)[0] || 'Remote task')
-            .replace(/[\r\n\t]/g, ' ')
-            .trim()
-            .slice(0, 120);
-
-        writeJsonLine(socket, {
+        const completedAt = new Date().toISOString();
+        const title = String(payload.title || instruction.split(/\r?\n/)[0] || 'Remote task')
+            .replace(/[\r\n\t]/g, ' ')
+            .trim()
+            .slice(0, 120);
+
+        writeJsonLine(socket, {
             type: 'command.result',
             commandId: message.commandId,
             result: {
@@ -2004,10 +1955,10 @@ function connectOnce(options, deviceId) {
                 hostname: os.hostname(),
                 platform: os.platform(),
                 arch: os.arch(),
-                pid: process.pid,
-                agentVersion: AGENT_VERSION,
-                productVersion: PRODUCT_VERSION,
-                capabilities: {
+                pid: process.pid,
+                agentVersion: AGENT_VERSION,
+                productVersion: PRODUCT_VERSION,
+                capabilities: {
                     status: true,
                     thumbnail: options.thumbnailEnabled,
                     liveStream: options.liveEnabled,
@@ -2022,13 +1973,13 @@ function connectOnce(options, deviceId) {
                     fileTransferMaxBytes: MAX_FILE_TRANSFER_BYTES,
                     computerAgent: options.taskEnabled,
                     taskDispatch: options.taskEnabled,
-                    clientUpdate: true,
-                    productVersion: PRODUCT_VERSION,
-                    agentApproval: options.taskEnabled,
-                    agentAudit: options.taskEnabled,
-                    agentTools: [...NODE_AGENT_OPERATIONS],
-                    elevation: typeof process.getuid === 'function' ? process.getuid() === 0 : false,
-                    externalEffects: options.taskEnabled
+                    clientUpdate: true,
+                    productVersion: PRODUCT_VERSION,
+                    agentApproval: options.taskEnabled,
+                    agentAudit: options.taskEnabled,
+                    agentTools: [...NODE_AGENT_OPERATIONS],
+                    elevation: typeof process.getuid === 'function' ? process.getuid() === 0 : false,
+                    externalEffects: options.taskEnabled
                 }
             });
         });
@@ -2045,12 +1996,12 @@ function connectOnce(options, deviceId) {
                 }
 
                 const message = JSON.parse(line);
-                if (message.type === 'welcome') {
-                    options.effectivePolicy = message.effectivePolicy && typeof message.effectivePolicy === 'object'
-                        ? message.effectivePolicy
+                if (message.type === 'welcome') {
+                    options.effectivePolicy = message.effectivePolicy && typeof message.effectivePolicy === 'object'
+                        ? message.effectivePolicy
                         : null;
-                    console.log(`Connected to LiveDesk Hub as ${options.name} (${deviceId})`);
-                    markClientUpdateConnected();
+                    console.log(`Connected to LiveDesk Hub as ${options.name} (${deviceId})`);
+                    markClientUpdateConnected();
                     writeJsonLine(socket, {
                         type: 'status',
                         status: getStatus(options)
@@ -2060,17 +2011,17 @@ function connectOnce(options, deviceId) {
                         return;
                     }
 
-                    heartbeatTimer = setInterval(() => {
-                        writeJsonLine(socket, {
-                            type: 'status',
-                            status: getStatus(options)
-                        });
-                    }, options.heartbeatMs);
-                } else if (message.type === 'policy.update') {
-                    options.effectivePolicy = message.effectivePolicy && typeof message.effectivePolicy === 'object'
-                        ? message.effectivePolicy
-                        : options.effectivePolicy;
-                } else if (message.type === 'command') {
+                    heartbeatTimer = setInterval(() => {
+                        writeJsonLine(socket, {
+                            type: 'status',
+                            status: getStatus(options)
+                        });
+                    }, options.heartbeatMs);
+                } else if (message.type === 'policy.update') {
+                    options.effectivePolicy = message.effectivePolicy && typeof message.effectivePolicy === 'object'
+                        ? message.effectivePolicy
+                        : options.effectivePolicy;
+                } else if (message.type === 'command') {
                     handleRemoteCommand(socket, options, message, () => {
                         frameSeq += 1;
                         return frameSeq;