livedesk 0.1.591 → 0.1.593

package/client/bin/livedesk-client-node.js

@@ -7,8 +7,8 @@ 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';
-import { resolveAgentShellCommand } from '../src/runtime/agent-shell.js';
+import { fileURLToPath } from 'node:url';
+import { resolveAgentShellCommand } from '../src/runtime/agent-shell.js';
 
 const require = createRequire(import.meta.url);
 const CLIENT_UPDATE_BOOTSTRAP_PATH = fileURLToPath(
@@ -40,7 +40,7 @@ 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}`);
+        throw new Error(`Invalid VuvoDesk product update version: ${version}`);
     }
     return version;
 }
@@ -64,7 +64,7 @@ async function prepareClientUpdateNeutralCwd(operationId) {
     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}`);
+        throw new Error(`VuvoDesk update neutral working directory is shadowed by ${shadowPath}: ${neutralCwd}`);
     }
     return neutralCwd;
 }
@@ -228,8 +228,8 @@ async function waitForClientUpdateShutdownSignal(
                 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}`);
+                const error = String(state.error || 'VuvoDesk client update preparation failed.');
+                console.error(`VuvoDesk client update preparation failed: ${error}`);
                 return { ready: false, error };
             }
         } catch {
@@ -239,8 +239,8 @@ async function waitForClientUpdateShutdownSignal(
     }
     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.';
+        ? 'The absolute VuvoDesk Client update deadline expired before shutdown.'
+        : 'Timed out waiting for the VuvoDesk update supervisor to prepare the exact package.';
     await writeClientUpdateState('failed', {
         operationId,
         error,
@@ -248,7 +248,7 @@ async function waitForClientUpdateShutdownSignal(
         deadlineExpired,
         failedAt: new Date().toISOString()
     }).catch(() => undefined);
-    console.error('LiveDesk client update preparation timed out; the current Agent will remain running.');
+    console.error('VuvoDesk client update preparation timed out; the current Agent will remain running.');
     return { ready: false, error };
 }
 
@@ -262,7 +262,7 @@ function markClientUpdateConnected() {
         restartVerified: true,
         error: ''
     }).catch(error => {
-        console.error(`LiveDesk client update diagnostics could not be persisted: ${error?.message || error}`);
+        console.error(`VuvoDesk client update diagnostics could not be persisted: ${error?.message || error}`);
     });
 }
 
@@ -319,14 +319,14 @@ async function publishClientUpdateSupervisorProof(socket) {
 
 function printHelp() {
     console.log(`
-LiveDesk Client
+VuvoDesk Client
 
 Usage:
   npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token>
 
 Options:
-  --manager <host:port>  LiveDesk Hub address. Default: ${DEFAULT_MANAGER}
-  --pair <token>         LiveDesk Hub pairing token. Can also use LIVEDESK_CLIENT_PAIR_TOKEN.
+  --manager <host:port>  VuvoDesk Hub address. Default: ${DEFAULT_MANAGER}
+  --pair <token>         VuvoDesk Hub pairing token. Can also use LIVEDESK_CLIENT_PAIR_TOKEN.
   --slot <number>        Screen wall slot number for this computer.
   --name <name>          Friendly device name. Default: OS hostname.
   --heartbeat <ms>       Status heartbeat interval. Default: ${DEFAULT_HEARTBEAT_MS}
@@ -337,7 +337,7 @@ Options:
   --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.
+  --files-dir <path>     Default folder for received files. Default: ~/Desktop/VuvoDeskFiles.
   --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.
@@ -685,7 +685,7 @@ async function waitForNodeServiceState(executable, service, expectedState, timeo
 }
 
 function getDefaultFilesDir() {
-    return path.join(os.homedir(), 'Desktop', 'LiveDeskFiles');
+    return path.join(os.homedir(), 'Desktop', 'VuvoDeskFiles');
 }
 
 function normalizeDirectoryPath(value, fallback = getDefaultFilesDir()) {
@@ -862,7 +862,7 @@ function createFakeThumbnailFrame(options, payload, frameSeq) {
         '<rect width="100%" height="100%" fill="#0f172a"/>',
         '<rect x="14" y="14" width="calc(100% - 28px)" height="calc(100% - 28px)" rx="12" fill="#1e293b" stroke="#38bdf8" stroke-width="2"/>',
         `<text x="28" y="48" fill="#e2e8f0" font-family="Arial, sans-serif" font-size="20" font-weight="700">${title}</text>`,
-        `<text x="28" y="82" fill="#93c5fd" font-family="Arial, sans-serif" font-size="14">LiveDesk Client Thumbnail</text>`,
+        `<text x="28" y="82" fill="#93c5fd" font-family="Arial, sans-serif" font-size="14">VuvoDesk Client Thumbnail</text>`,
         `<text x="28" y="${height - 30}" fill="#94a3b8" font-family="Consolas, monospace" font-size="12">${now}</text>`,
         '</svg>'
     ].join('');
@@ -1119,7 +1119,7 @@ async function assertAgentPathDoesNotTraverseLink(base, resolved) {
             }
             const canonicalCurrent = await fs.realpath(current);
             if (!isPathWithinAgentRoot(canonicalRoot, canonicalCurrent)) {
-                throw new Error('Safe Agent path resolves outside the LiveDesk files directory.');
+                throw new Error('Safe Agent path resolves outside the VuvoDesk files directory.');
             }
             return;
         } catch (error) {
@@ -1137,16 +1137,16 @@ async function resolveAgentPath(options, value, permissionMode, rejectSensitive
     if (!text || text.length > 600) throw new Error('path is invalid');
     const resolved = path.resolve(path.isAbsolute(text) ? text : path.join(base, text));
     const relative = path.relative(base, resolved);
-    if (permissionMode !== 'full-access' && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) throw new Error('path is outside the LiveDesk files directory for this permission mode');
+    if (permissionMode !== 'full-access' && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) throw new Error('path is outside the VuvoDesk files directory for this permission mode');
     if (permissionMode !== 'full-access') await assertAgentPathDoesNotTraverseLink(base, resolved);
     if (rejectSensitive && isSensitiveAgentPath(resolved)) throw new Error('credential and secret paths are not available');
     return resolved;
 }
 
-function runNodeAgentProcess(executable, args, timeoutMs = 15000, cwd = undefined, maxTimeoutMs = 30000) {
-    return new Promise((resolve, reject) => {
-        const startedAt = Date.now();
-        const child = spawn(executable, args, { cwd, windowsHide: true, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+function runNodeAgentProcess(executable, args, timeoutMs = 15000, cwd = undefined, maxTimeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+        const startedAt = Date.now();
+        const child = spawn(executable, args, { cwd, windowsHide: true, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
         let output = '';
         let timedOut = false;
         const append = chunk => { output = `${output}${String(chunk || '')}`.replace(/[\0\r]/g, ' ').slice(0, MAX_AGENT_OUTPUT_CHARS); };
@@ -1156,55 +1156,55 @@ function runNodeAgentProcess(executable, args, timeoutMs = 15000, cwd = undefine
             timedOut = true;
             child.kill('SIGTERM');
             setTimeout(() => child.kill('SIGKILL'), 1000).unref?.();
-        }, Math.max(1000, Math.min(maxTimeoutMs, Number(timeoutMs) || 15000)));
-        child.once('error', error => { clearTimeout(timer); reject(error); });
-        child.once('close', code => { clearTimeout(timer); resolve({ output: redactAgentOutput(`${output}${timedOut ? '\n[timeout]' : ''}`.trim()), exitCode: timedOut ? -1 : code ?? -1, timedOut, durationMs: Date.now() - startedAt }); });
-    });
-}
-
-async function searchNodeAgentFiles(options, args, permissionMode) {
-    const root = await resolveAgentPath(options, args.path, permissionMode);
-    const query = String(args.query || '').trim().toLowerCase();
-    if (!query || query.length > 160 || /[\0\r\n]/.test(query)) throw new Error('search query is invalid');
-    const maxResults = Math.max(1, Math.min(200, Number(args.maxResults) || 100));
-    const maxDepth = Math.max(0, Math.min(8, Number(args.maxDepth) || 4));
-    const maxScannedEntries = Math.max(maxResults, Math.min(5000, Number(args.maxScannedEntries) || 2000));
-    const queue = [{ directory: root, depth: 0 }];
-    const matches = [];
-    let scannedEntries = 0;
-    while (queue.length > 0 && matches.length < maxResults && scannedEntries < maxScannedEntries) {
-        const current = queue.shift();
-        let entries;
-        try {
-            entries = await fs.readdir(current.directory, { withFileTypes: true });
-        } catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (matches.length >= maxResults || scannedEntries >= maxScannedEntries) break;
-            scannedEntries += 1;
-            const entryPath = path.join(current.directory, entry.name);
-            if (isSensitiveAgentPath(entryPath)) continue;
-            const isDirectory = entry.isDirectory();
-            if (entry.name.toLowerCase().includes(query)) {
-                matches.push({ name: entry.name, path: entryPath, type: isDirectory ? 'directory' : 'file' });
-            }
-            if (isDirectory && current.depth < maxDepth && !entry.isSymbolicLink()) {
-                queue.push({ directory: entryPath, depth: current.depth + 1 });
-            }
-        }
-    }
-    return {
-        summary: `Found ${matches.length} matching path${matches.length === 1 ? '' : 's'}.`,
-        data: {
-            path: root,
-            query,
-            matches,
-            scannedEntries,
-            truncated: matches.length >= maxResults || scannedEntries >= maxScannedEntries
-        }
-    };
-}
+        }, Math.max(1000, Math.min(maxTimeoutMs, Number(timeoutMs) || 15000)));
+        child.once('error', error => { clearTimeout(timer); reject(error); });
+        child.once('close', code => { clearTimeout(timer); resolve({ output: redactAgentOutput(`${output}${timedOut ? '\n[timeout]' : ''}`.trim()), exitCode: timedOut ? -1 : code ?? -1, timedOut, durationMs: Date.now() - startedAt }); });
+    });
+}
+
+async function searchNodeAgentFiles(options, args, permissionMode) {
+    const root = await resolveAgentPath(options, args.path, permissionMode);
+    const query = String(args.query || '').trim().toLowerCase();
+    if (!query || query.length > 160 || /[\0\r\n]/.test(query)) throw new Error('search query is invalid');
+    const maxResults = Math.max(1, Math.min(200, Number(args.maxResults) || 100));
+    const maxDepth = Math.max(0, Math.min(8, Number(args.maxDepth) || 4));
+    const maxScannedEntries = Math.max(maxResults, Math.min(5000, Number(args.maxScannedEntries) || 2000));
+    const queue = [{ directory: root, depth: 0 }];
+    const matches = [];
+    let scannedEntries = 0;
+    while (queue.length > 0 && matches.length < maxResults && scannedEntries < maxScannedEntries) {
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = await fs.readdir(current.directory, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (matches.length >= maxResults || scannedEntries >= maxScannedEntries) break;
+            scannedEntries += 1;
+            const entryPath = path.join(current.directory, entry.name);
+            if (isSensitiveAgentPath(entryPath)) continue;
+            const isDirectory = entry.isDirectory();
+            if (entry.name.toLowerCase().includes(query)) {
+                matches.push({ name: entry.name, path: entryPath, type: isDirectory ? 'directory' : 'file' });
+            }
+            if (isDirectory && current.depth < maxDepth && !entry.isSymbolicLink()) {
+                queue.push({ directory: entryPath, depth: current.depth + 1 });
+            }
+        }
+    }
+    return {
+        summary: `Found ${matches.length} matching path${matches.length === 1 ? '' : 's'}.`,
+        data: {
+            path: root,
+            query,
+            matches,
+            scannedEntries,
+            truncated: matches.length >= maxResults || scannedEntries >= maxScannedEntries
+        }
+    };
+}
 
 function redactAgentOutput(value) {
     let output = String(value || '').replace(/[\0\r]/g, ' ');
@@ -1330,7 +1330,7 @@ async function persistNodeEnvironmentVariable(name, value) {
         return { persisted: true, scope: 'user', output: result.output };
     }
     const profilePath = path.join(os.homedir(), '.profile');
-    const marker = `# LiveDesk managed environment: ${variableName}`;
+    const marker = `# VuvoDesk managed environment: ${variableName}`;
     const quoted = `'${variableValue.replaceAll("'", "'\\\"'\\\"'")}'`;
     let profile = '';
     try { profile = await fs.readFile(profilePath, 'utf8'); } catch { /* create on demand */ }
@@ -1370,7 +1370,7 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
         else await fs.unlink(filePath);
         return { summary: `Deleted ${path.basename(filePath)}.`, data: { path: filePath, recursive: args.recursive === true } };
     }
-    if (operation === 'file.list') {
+    if (operation === 'file.list') {
         const directory = await resolveAgentPath(options, args.path, permissionMode);
         const entries = await fs.readdir(directory, { withFileTypes: true });
         const maxEntries = Math.max(1, Math.min(500, Number(args.maxEntries) || 200));
@@ -1380,15 +1380,15 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
             if (isSensitiveAgentPath(entryPath)) continue;
             data.push({ name: entry.name, path: entryPath, type: entry.isDirectory() ? 'directory' : 'file', sizeBytes: entry.isDirectory() ? 0 : (await fs.stat(entryPath)).size });
         }
-        return { summary: `Listed ${data.length} entries.`, data: { path: directory, entries: data, truncated: entries.length > maxEntries } };
-    }
-    if (operation === 'file.search') return searchNodeAgentFiles(options, args, permissionMode);
-    if (operation === 'directory.create') {
-        let directory = await resolveAgentPath(options, args.path, permissionMode);
-        await fs.mkdir(directory, { recursive: true });
-        directory = await resolveAgentPath(options, args.path, permissionMode);
-        return { summary: `Created directory ${path.basename(directory)}.`, data: { path: directory, created: true } };
-    }
+        return { summary: `Listed ${data.length} entries.`, data: { path: directory, entries: data, truncated: entries.length > maxEntries } };
+    }
+    if (operation === 'file.search') return searchNodeAgentFiles(options, args, permissionMode);
+    if (operation === 'directory.create') {
+        let directory = await resolveAgentPath(options, args.path, permissionMode);
+        await fs.mkdir(directory, { recursive: true });
+        directory = await resolveAgentPath(options, args.path, permissionMode);
+        return { summary: `Created directory ${path.basename(directory)}.`, data: { path: directory, created: true } };
+    }
     if (operation === 'application.launch') {
         const executable = String(args.executable || '').trim();
         if (!executable || executable.length > 400 || /[\0\r\n]/.test(executable)) throw new Error('executable is invalid');
@@ -1442,13 +1442,13 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
         if (!ok) throw new Error(`Service ${action} failed for ${service}.`);
         return { summary: `Service ${action} completed for ${service}.`, data: { service, action, results } };
     }
-    if (operation === 'command.run') {
-        const command = String(args.command || '');
-        if (!command || command.length > 16000 || /\0/.test(command)) throw new Error('command is invalid');
-        const shellCommand = resolveAgentShellCommand({ shell: args.shell, command });
-        const workingDirectory = args.workingDirectory ? await resolveAgentPath(options, args.workingDirectory, permissionMode, false) : undefined;
-        const result = await runNodeAgentProcess(shellCommand.executable, shellCommand.args, args.timeoutMs, workingDirectory, 300000);
-        return { summary: result.timedOut ? `${shellCommand.shell} command timed out.` : `${shellCommand.shell} command exited with code ${result.exitCode}.`, data: { ...result, output: redactAgentOutput(result.output), shell: shellCommand.shell, workingDirectory: workingDirectory || process.cwd() } };
+    if (operation === 'command.run') {
+        const command = String(args.command || '');
+        if (!command || command.length > 16000 || /\0/.test(command)) throw new Error('command is invalid');
+        const shellCommand = resolveAgentShellCommand({ shell: args.shell, command });
+        const workingDirectory = args.workingDirectory ? await resolveAgentPath(options, args.workingDirectory, permissionMode, false) : undefined;
+        const result = await runNodeAgentProcess(shellCommand.executable, shellCommand.args, args.timeoutMs, workingDirectory, 300000);
+        return { summary: result.timedOut ? `${shellCommand.shell} command timed out.` : `${shellCommand.shell} command exited with code ${result.exitCode}.`, data: { ...result, output: redactAgentOutput(result.output), shell: shellCommand.shell, workingDirectory: workingDirectory || process.cwd() } };
     }
     if (operation === 'script.run') {
         const scriptPath = await resolveAgentPath(options, args.path, permissionMode);
@@ -1535,7 +1535,7 @@ function normalizeNodeAgentTaskResult(result) {
     return { ...result, ok, status: ok ? 'completed' : 'failed', error };
 }
 
-const NODE_AGENT_OPERATIONS = new Set(['process.control', 'service.control', 'application.launch', 'application.close', 'file.read', 'file.write', 'file.delete', 'file.list', 'file.search', 'directory.create', 'command.run', 'script.run', 'software.install', 'network.status', 'system.power', 'system.configure', 'logs.collect']);
+const NODE_AGENT_OPERATIONS = new Set(['process.control', 'service.control', 'application.launch', 'application.close', 'file.read', 'file.write', 'file.delete', 'file.list', 'file.search', 'directory.create', 'command.run', 'script.run', 'software.install', 'network.status', 'system.power', 'system.configure', 'logs.collect']);
 
 function remotePolicyAllows(options, command) {
     const policy = options.effectivePolicy;
@@ -1587,7 +1587,7 @@ async function scheduleClientUpdate(options, payload = {}) {
         if (!Number.isSafeInteger(updateTimeoutMs)
             || updateTimeoutMs < 1_000
             || updateTimeoutMs > 90 * 60_000) {
-            throw new Error('LiveDesk Client update requires a bounded deadline budget.');
+            throw new Error('VuvoDesk Client update requires a bounded deadline budget.');
         }
         updateDeadlineEpochMs = Date.now() + updateTimeoutMs;
         const originalCwd = path.resolve(process.cwd());
@@ -1608,7 +1608,7 @@ async function scheduleClientUpdate(options, payload = {}) {
             ? configuredParentPid
             : process.pid;
         if (!Number.isInteger(parentPid) || parentPid <= 1) {
-            throw new Error('LiveDesk client launcher process id is unavailable.');
+            throw new Error('VuvoDesk client launcher process id is unavailable.');
         }
         const nodeBinDir = path.dirname(process.execPath);
         const npxCandidates = process.platform === 'win32'
@@ -1616,7 +1616,7 @@ async function scheduleClientUpdate(options, payload = {}) {
             : [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.');
+            throw new Error('VuvoDesk npx executable was not found.');
         }
         const frozenCommand = path.isAbsolute(command) || !/[\\/]/.test(command)
             ? command
@@ -1651,7 +1651,7 @@ async function scheduleClientUpdate(options, payload = {}) {
         }, 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}`);
+            throw new Error(`VuvoDesk Client update bootstrap is unavailable: ${CLIENT_UPDATE_BOOTSTRAP_PATH}`);
         }
         return await new Promise((resolve, reject) => {
             const child = spawn(process.execPath, [CLIENT_UPDATE_BOOTSTRAP_PATH], {
@@ -1777,7 +1777,7 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
                     summary: result.summary,
                     error: result.error || undefined,
                     data: result.data,
-                    sideEffects: ['file.read', 'file.list', 'file.search', 'network.status', 'logs.collect'].includes(command) ? 'none' : 'audited',
+                    sideEffects: ['file.read', 'file.list', 'file.search', 'network.status', 'logs.collect'].includes(command) ? 'none' : 'audited',
                     completedAt: new Date().toISOString()
                 }
             });
@@ -2008,7 +2008,7 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
 function connectOnce(options, deviceId) {
     const manager = parseManagerAddress(options.manager);
     if (!isPrivateLanHost(manager.host) && !isTruthy(process.env.LIVEDESK_ALLOW_UNENCRYPTED_LAN)) {
-        return Promise.reject(new Error('Plain TCP LiveDesk connections are limited to loopback/private LAN. Use an encrypted endpoint for external connections.'));
+        return Promise.reject(new Error('Plain TCP VuvoDesk connections are limited to loopback/private LAN. Use an encrypted endpoint for external connections.'));
     }
     return new Promise((resolve, reject) => {
         const socket = net.createConnection({
@@ -2106,11 +2106,11 @@ function connectOnce(options, deviceId) {
                     options.effectivePolicy = message.effectivePolicy && typeof message.effectivePolicy === 'object'
                         ? message.effectivePolicy
                         : null;
-                    console.log(`Connected to LiveDesk Hub as ${options.name} (${deviceId})`);
+                    console.log(`Connected to VuvoDesk Hub as ${options.name} (${deviceId})`);
                     markClientUpdateConnected();
                     void publishClientUpdateSupervisorProof(socket).catch(error => {
                         if (!socket.destroyed) {
-                            console.error(`LiveDesk client update verification proof failed: ${error?.message || error}`);
+                            console.error(`VuvoDesk client update verification proof failed: ${error?.message || error}`);
                         }
                     });
                     writeJsonLine(socket, {
@@ -2147,7 +2147,7 @@ function connectOnce(options, deviceId) {
                     finish();
                     return;
                 } else if (message.type === 'error') {
-                    const remoteError = new Error(message.error || 'LiveDesk Hub rejected the connection.');
+                    const remoteError = new Error(message.error || 'VuvoDesk Hub rejected the connection.');
                     if (message.error === 'invalid-pair-token' && options.exitOnInvalidPair) {
                         remoteError.exitCode = EXIT_INVALID_PAIR_TOKEN;
                     }
@@ -2164,7 +2164,7 @@ function connectOnce(options, deviceId) {
 
 async function connectWithRetry(options) {
     if (!options.pair) {
-        throw new Error('Missing --pair token. Sign in with Google or get it from LiveDesk Hub status.');
+        throw new Error('Missing --pair token. Sign in with Google or get it from VuvoDesk Hub status.');
     }
 
     const deviceId = await getDeviceId(options.deviceId);
@@ -2173,7 +2173,7 @@ async function connectWithRetry(options) {
 
     process.once('SIGINT', () => {
         stopping = true;
-        console.log('\nStopping LiveDesk Client...');
+        console.log('\nStopping VuvoDesk Client...');
     });
     process.once('SIGTERM', () => {
         stopping = true;
@@ -2192,7 +2192,7 @@ async function connectWithRetry(options) {
                 throw err;
             }
             const delayMs = DEFAULT_RECONNECT_MS;
-            console.error(`LiveDesk Hub connection failed: ${err?.message || err}. Retrying in ${delayMs}ms.`);
+            console.error(`VuvoDesk Hub connection failed: ${err?.message || err}. Retrying in ${delayMs}ms.`);
             await wait(delayMs);
         }
     }

package/client/bin/livedesk-client-update-bootstrap.cjs

@@ -79,7 +79,7 @@ function withStateLock(callback) {
       }
       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}`);
+      if (Date.now() >= deadline) throw new Error(`Timed out waiting for the VuvoDesk update state lock: ${stateLockPath}`);
       Atomics.wait(lockWaitBuffer, 0, 0, Math.min(25, Math.max(1, deadline - Date.now())));
     }
   }
@@ -125,26 +125,26 @@ function writeFailure(error, cancelRequested = false) {
       };
     }, 'handoff-failed');
   } catch { /* preserve the original handoff failure */ }
-  process.stderr.write(`LiveDesk update handoff failed: ${error?.message || error}\n`);
+  process.stderr.write(`VuvoDesk update handoff failed: ${error?.message || error}\n`);
   process.exitCode = 1;
 }
 
 function prepareNeutralCwd() {
-  if (!neutralCwd) throw new Error('LiveDesk update neutral working directory is unavailable.');
+  if (!neutralCwd) throw new Error('VuvoDesk update neutral working directory is unavailable.');
   fs.mkdirSync(neutralCwd, { recursive: true });
   const unexpectedEntry = fs.readdirSync(neutralCwd)[0];
   if (unexpectedEntry) {
-    throw new Error(`LiveDesk update neutral working directory is shadowed by ${path.join(neutralCwd, unexpectedEntry)}.`);
+    throw new Error(`VuvoDesk update neutral working directory is shadowed by ${path.join(neutralCwd, unexpectedEntry)}.`);
   }
 }
 
 function writeHandoffStarted() {
   return writeState(previous => {
     if (Date.now() >= updateDeadlineEpochMs) {
-      throw new Error('The absolute LiveDesk Client update deadline expired before handoff.');
+      throw new Error('The absolute VuvoDesk Client update deadline expired before handoff.');
     }
     if (previous.operationId !== operationId) {
-      throw new Error('LiveDesk update handoff was superseded before exact-package launch.');
+      throw new Error('VuvoDesk update handoff was superseded before exact-package launch.');
     }
     const now = new Date().toISOString();
     return {
@@ -175,7 +175,7 @@ function submitUpdateHostJob(job) {
       || status?.protocolVersion !== UPDATE_HOST_PROTOCOL_VERSION
       || !endpoint
       || !/^[a-f0-9]{64}$/i.test(token)) {
-      rejectRequest(new Error('The independent LiveDesk Update Host is unavailable; the existing Client was left running.'));
+      rejectRequest(new Error('The independent VuvoDesk Update Host is unavailable; the existing Client was left running.'));
       return;
     }
     const request = JSON.stringify({
@@ -185,7 +185,7 @@ function submitUpdateHostJob(job) {
       job
     });
     if (Buffer.byteLength(request, 'utf8') > UPDATE_HOST_MAX_MESSAGE_BYTES) {
-      rejectRequest(new Error('The LiveDesk Client update request exceeded the Update Host message limit.'));
+      rejectRequest(new Error('The VuvoDesk Client update request exceeded the Update Host message limit.'));
       return;
     }
     const socket = net.createConnection(endpoint);
@@ -207,7 +207,7 @@ function submitUpdateHostJob(job) {
     socket.on('data', chunk => {
       responseText += chunk;
       if (Buffer.byteLength(responseText, 'utf8') > UPDATE_HOST_MAX_MESSAGE_BYTES) {
-        finish(new Error('The LiveDesk Update Host response exceeded its message limit.'));
+        finish(new Error('The VuvoDesk Update Host response exceeded its message limit.'));
       }
     });
     socket.once('error', error => finish(error));
@@ -215,7 +215,7 @@ function submitUpdateHostJob(job) {
       try {
         const response = JSON.parse(responseText || '{}');
         if (response?.ok !== true || response?.accepted !== true || Number(response?.job?.workerPid || 0) <= 1) {
-          throw new Error(String(response?.error || 'The LiveDesk Update Host did not accept the Client update.'));
+          throw new Error(String(response?.error || 'The VuvoDesk Update Host did not accept the Client update.'));
         }
         finish(null, response);
       } catch (error) {
@@ -269,7 +269,7 @@ function buildWorkerInvocation(env) {
 async function main() {
   if (!operationId || !versionPattern.test(targetProductVersion)
     || !Number.isSafeInteger(updateDeadlineEpochMs) || Date.now() >= updateDeadlineEpochMs) {
-    throw new Error('Invalid or expired LiveDesk exact-package update handoff.');
+    throw new Error('Invalid or expired VuvoDesk exact-package update handoff.');
   }
   prepareNeutralCwd();
   writeHandoffStarted();
@@ -289,7 +289,7 @@ async function main() {
 
   const invocation = buildWorkerInvocation(env);
   if (!path.isAbsolute(invocation.command) || !fs.existsSync(invocation.command)) {
-    throw new Error('LiveDesk could not prepare an absolute Client update worker command for the independent Update Host.');
+    throw new Error('VuvoDesk could not prepare an absolute Client update worker command for the independent Update Host.');
   }
   const result = await submitUpdateHostJob({
     jobId: `client-${operationId.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 160)}`,