@livedesk/client 0.1.235 → 0.1.236

package/bin/livedesk-client-node.js

@@ -1,15 +1,13 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import net from 'net';
 import os from 'os';
 import path from 'path';
 import crypto from 'crypto';
-import { constants as fsConstants, existsSync, promises as fs, statfsSync } from 'fs';
+import { existsSync, promises as fs, statfsSync } from 'fs';
 import { spawn } from 'child_process';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { createClientDeviceCredentialStore } from '../src/security/device-credential-store.js';
-import { connectSecureDirect } from '../src/security/secure-direct-client.js';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const CLIENT_UPDATE_BOOTSTRAP_PATH = fileURLToPath(
@@ -659,7 +657,7 @@ function sanitizePathSegment(value, fallback = 'file') {
     return normalized.slice(0, 160);
 }
 
-function sanitizeRelativeFilePath(value, fallbackName = 'file') {
+function sanitizeRelativeFilePath(value, fallbackName = 'file') {
     const parts = String(value || '')
         .replace(/\0/g, '')
         .split(/[\\/]+/)
@@ -670,52 +668,7 @@ function sanitizeRelativeFilePath(value, fallbackName = 'file') {
         return sanitizePathSegment(fallbackName, 'file');
     }
     return path.join(...parts.slice(-8));
-}
-
-function isPathInsideRoot(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
-}
-
-async function resolveReceiveDirectory(options, remoteDirectory) {
-    const configuredRoot = path.resolve(options.filesDir || getDefaultFilesDir());
-    await fs.mkdir(configuredRoot, { recursive: true });
-    const rootStat = await fs.lstat(configuredRoot);
-    if (rootStat.isSymbolicLink()) throw new Error('The LiveDesk receive root cannot be a symbolic link or junction.');
-    const canonicalRoot = await fs.realpath(configuredRoot);
-    const relativeDirectory = String(remoteDirectory || '').replace(/\0/g, '').trim();
-    if (relativeDirectory.length > 600 || path.isAbsolute(relativeDirectory)) {
-        throw new Error('The remote receive directory must be relative to the LiveDesk files root.');
-    }
-    const candidate = path.resolve(canonicalRoot, relativeDirectory || '.');
-    if (!isPathInsideRoot(canonicalRoot, candidate)) throw new Error('The remote receive directory escapes the LiveDesk files root.');
-    await assertAgentPathDoesNotTraverseLink(canonicalRoot, candidate);
-    await fs.mkdir(candidate, { recursive: true });
-    await assertAgentPathDoesNotTraverseLink(canonicalRoot, candidate);
-    const canonicalCandidate = await fs.realpath(candidate);
-    if (!isPathInsideRoot(canonicalRoot, canonicalCandidate)) throw new Error('The remote receive directory resolves outside the LiveDesk files root.');
-    return { root: canonicalRoot, directory: canonicalCandidate };
-}
-
-function requireFileSha256(value) {
-    const hash = String(value || '').trim().toLowerCase();
-    if (!/^[a-f0-9]{64}$/.test(hash)) throw new Error('A valid SHA-256 file hash is required.');
-    return hash;
-}
-
-function hashBuffer(buffer) {
-    return crypto.createHash('sha256').update(buffer).digest('hex');
-}
-
-async function commitNewFile(tempPath, targetPath) {
-    try {
-        await fs.link(tempPath, targetPath);
-    } catch (error) {
-        if (error?.code === 'EEXIST') throw new Error(`Refusing to overwrite an existing file: ${path.basename(targetPath)}`);
-        throw error;
-    }
-    await fs.rm(tempPath, { force: true });
-}
+}
 
 async function handleFileTransferCommand(options, payload = {}) {
     const files = Array.isArray(payload.files) ? payload.files.slice(0, MAX_FILE_TRANSFER_FILES) : [];
@@ -723,46 +676,32 @@ async function handleFileTransferCommand(options, payload = {}) {
         throw new Error('No files were included in the transfer.');
     }
 
-    const { root, directory: baseDir } = await resolveReceiveDirectory(options, payload.remoteDirectory);
+    const baseDir = normalizeDirectoryPath(payload.remoteDirectory || options.filesDir);
+    await fs.mkdir(baseDir, { recursive: true });
 
     let totalBytes = 0;
     const saved = [];
     for (const file of files) {
         const name = sanitizePathSegment(file?.name, 'file');
         const relativePath = sanitizeRelativeFilePath(file?.relativePath || name, name);
-        const targetPath = path.resolve(baseDir, relativePath);
-        if (!isPathInsideRoot(baseDir, targetPath)) {
-            throw new Error(`Unsafe file path: ${relativePath}`);
-        }
+        const targetPath = path.resolve(baseDir, relativePath);
+        const relativeFromBase = path.relative(baseDir, targetPath);
+        if (relativeFromBase.startsWith('..') || path.isAbsolute(relativeFromBase)) {
+            throw new Error(`Unsafe file path: ${relativePath}`);
+        }
 
         const dataBase64 = String(file?.dataBase64 || '').replace(/^data:[^,]*,/i, '').trim();
         if (!dataBase64) {
             throw new Error(`Missing file data: ${name}`);
         }
-        const buffer = Buffer.from(dataBase64, 'base64');
-        const expectedSha256 = requireFileSha256(file?.sha256);
-        if (hashBuffer(buffer) !== expectedSha256) throw new Error(`File SHA-256 mismatch: ${name}`);
+        const buffer = Buffer.from(dataBase64, 'base64');
         totalBytes += buffer.length;
         if (totalBytes > MAX_FILE_TRANSFER_BYTES) {
             throw new Error('File transfer exceeded the local size limit.');
         }
 
-        await fs.mkdir(path.dirname(targetPath), { recursive: true });
-        await assertAgentPathDoesNotTraverseLink(root, path.dirname(targetPath));
-        await assertAgentPathDoesNotTraverseLink(root, targetPath);
-        const tempPath = `${targetPath}.livedesk-${crypto.randomBytes(12).toString('hex')}.part`;
-        try {
-            const handle = await fs.open(tempPath, 'wx', 0o600);
-            try {
-                await handle.writeFile(buffer);
-                await handle.sync();
-            } finally {
-                await handle.close();
-            }
-            await commitNewFile(tempPath, targetPath);
-        } finally {
-            await fs.rm(tempPath, { force: true }).catch(() => undefined);
-        }
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.writeFile(targetPath, buffer);
         saved.push({
             name,
             relativePath,
@@ -783,11 +722,12 @@ async function handleFileTransferCommand(options, payload = {}) {
 }
 
 async function handleFileTransferChunkCommand(options, payload = {}) {
-    const { root, directory: baseDir } = await resolveReceiveDirectory(options, payload.remoteDirectory);
+    const baseDir = normalizeDirectoryPath(payload.remoteDirectory || options.filesDir);
     const name = sanitizePathSegment(payload.name, 'file');
     const relativePath = sanitizeRelativeFilePath(payload.relativePath || name, name);
     const targetPath = path.resolve(baseDir, relativePath);
-    if (!isPathInsideRoot(baseDir, targetPath)) {
+    const relativeFromBase = path.relative(baseDir, targetPath);
+    if (relativeFromBase.startsWith('..') || path.isAbsolute(relativeFromBase)) {
         throw new Error(`Unsafe file path: ${relativePath}`);
     }
 
@@ -796,31 +736,19 @@ async function handleFileTransferChunkCommand(options, payload = {}) {
     const totalBytes = Math.max(0, Math.floor(Number(payload.totalBytes) || 0));
     const final = payload.final === true;
     const buffer = payload.dataBase64 ? Buffer.from(String(payload.dataBase64), 'base64') : Buffer.alloc(0);
-    if (!transferId || totalBytes > MAX_FILE_TRANSFER_BYTES || offset > totalBytes || offset + buffer.length > totalBytes || buffer.length > 512 * 1024) {
+    if (!transferId || offset > totalBytes || offset + buffer.length > totalBytes || buffer.length > 512 * 1024) {
         throw new Error('Invalid file transfer chunk.');
     }
     if (buffer.length === 0 && !(final && totalBytes === 0 && offset === 0)) {
         throw new Error('Empty file chunks are not allowed.');
     }
 
-    await fs.mkdir(path.dirname(targetPath), { recursive: true });
-    await assertAgentPathDoesNotTraverseLink(root, path.dirname(targetPath));
-    await assertAgentPathDoesNotTraverseLink(root, targetPath);
-    const tempPath = `${targetPath}.livedesk-${transferId}.part`;
-    if (offset > 0) {
-        const staging = await fs.lstat(tempPath);
-        if (!staging.isFile() || staging.isSymbolicLink() || staging.nlink !== 1) {
-            throw new Error('Unsafe file transfer staging path.');
-        }
-    }
-    const openFlags = offset === 0
-        ? fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_RDWR
-        : fsConstants.O_RDWR | (fsConstants.O_NOFOLLOW || 0);
-    const handle = await fs.open(tempPath, openFlags, 0o600);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.livedesk-${transferId}.part`;
+    const handle = await fs.open(tempPath, offset === 0 ? 'w+' : 'r+');
     let completedSize = 0;
     try {
-        const before = await handle.stat();
-        if (!before.isFile() || before.nlink !== 1) throw new Error('Unsafe file transfer staging path.');
+        const before = await handle.stat();
         if (offset > before.size) {
             throw new Error(`File chunk gap detected at ${offset}; current length is ${before.size}.`);
         }
@@ -839,19 +767,9 @@ async function handleFileTransferChunkCommand(options, payload = {}) {
         await handle.close();
     }
 
-    if (final) {
-        const expectedSha256 = requireFileSha256(payload.sha256);
-        const received = await fs.readFile(tempPath);
-        if (hashBuffer(received) !== expectedSha256) {
-            await fs.rm(tempPath, { force: true });
-            throw new Error('File SHA-256 mismatch.');
-        }
-        try {
-            await commitNewFile(tempPath, targetPath);
-        } catch (error) {
-            await fs.rm(tempPath, { force: true });
-            throw error;
-        }
+    if (final) {
+        await fs.rm(targetPath, { force: true });
+        await fs.rename(tempPath, targetPath);
         const lastModified = Number(payload.lastModified || 0);
         if (lastModified > 0) {
             const modifiedAt = new Date(lastModified);
@@ -1512,20 +1430,7 @@ function normalizeNodeAgentTaskResult(result) {
     return { ...result, ok, status: ok ? 'completed' : 'failed', error };
 }
 
-const NODE_AGENT_OPERATIONS = new Set(['file.read', 'file.list', 'network.status', 'logs.collect']);
-const RETIRED_NODE_AGENT_MUTATING_OPERATIONS = new Set([
-    'process.control',
-    'service.control',
-    'application.launch',
-    'application.close',
-    'file.write',
-    'file.delete',
-    'command.run',
-    'script.run',
-    'software.install',
-    'system.power',
-    'system.configure'
-]);
+const NODE_AGENT_OPERATIONS = new Set(['process.control', 'service.control', 'application.launch', 'application.close', 'file.read', 'file.write', 'file.delete', 'file.list', 'command.run', 'script.run', 'software.install', 'network.status', 'system.power', 'system.configure', 'logs.collect']);
 
 function remotePolicyAllows(options, command) {
     const policy = options.effectivePolicy;
@@ -1682,8 +1587,8 @@ async function scheduleClientUpdate(options, payload = {}) {
     }
 }
 
-async function handleRemoteCommand(socket, options, message, nextFrameSeq, activeStreams) {
-    const command = String(message.command || '');
+async function handleRemoteCommand(socket, options, message, nextFrameSeq, activeStreams) {
+    const command = String(message.command || '');
     if (command === 'ping') {
         writeJsonLine(socket, {
             type: 'command.result',
@@ -1693,20 +1598,8 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
                 at: new Date().toISOString()
             }
         });
-        return;
-    }
-
-    // LD-SEC-AI-001 is enforced before settings or permission modes. A stale
-    // Hub can therefore never revive a retired mutation with full-access.
-    if (RETIRED_NODE_AGENT_MUTATING_OPERATIONS.has(command)) {
-        writeJsonLine(socket, {
-            type: 'command.result',
-            commandId: message.commandId,
-            error: 'agent-mutating-tool-disabled',
-            result: { ok: false, status: 'rejected', error: 'agent-mutating-tool-disabled', sideEffects: 'none' }
-        });
-        return;
-    }
+        return;
+    }
 
     const policyDecision = remotePolicyAllows(options, command);
     if (!policyDecision.ok) {
@@ -2007,20 +1900,18 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
     });
 }
 
-async function connectOnce(options, deviceId) {
-    const manager = parseManagerAddress(options.manager);
-    const credentialStore = createClientDeviceCredentialStore({ deviceId });
-    const socket = await connectSecureDirect({
-        host: manager.host,
-        port: manager.port,
-        channel: 'control',
-        deviceId,
-        enrollmentToken: options.pair,
-        credentialStore,
-        timeoutMs: 5000
-    });
-    return new Promise((resolve, reject) => {
-        let buffer = '';
+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 new Promise((resolve, reject) => {
+        const socket = net.createConnection({
+            host: manager.host,
+            port: manager.port
+        });
+
+        let buffer = '';
         let heartbeatTimer = null;
         let resolved = false;
         let frameSeq = 0;
@@ -2054,43 +1945,44 @@ async function connectOnce(options, deviceId) {
         socket.setNoDelay(true);
         socket.setKeepAlive(true, options.heartbeatMs);
 
-        writeJsonLine(socket, {
-            type: 'hello',
-            deviceId,
-            deviceName: options.name,
-            slotNumber: options.slotNumber || undefined,
-            hostname: os.hostname(),
-            platform: os.platform(),
-            arch: os.arch(),
-            pid: process.pid,
-            agentVersion: AGENT_VERSION,
-            productVersion: PRODUCT_VERSION,
-            capabilities: {
-                status: true,
-                thumbnail: options.thumbnailEnabled,
-                liveStream: options.liveEnabled,
-                monitorSelection: true,
-                screenCount: 1,
-                monitorCount: 1,
-                control: false,
-                audio: false,
-                remoteAudio: false,
-                fileTransfer: true,
-                remoteFiles: true,
-                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: false,
-                authenticatedDeviceCredential: true,
-                encryptedDirect: true
-            }
-        });
+        socket.once('connect', () => {
+            writeJsonLine(socket, {
+                type: 'hello',
+                pairToken: options.pair,
+                deviceId,
+                deviceName: options.name,
+                slotNumber: options.slotNumber || undefined,
+                hostname: os.hostname(),
+                platform: os.platform(),
+                arch: os.arch(),
+                pid: process.pid,
+                agentVersion: AGENT_VERSION,
+                productVersion: PRODUCT_VERSION,
+                capabilities: {
+                    status: true,
+                    thumbnail: options.thumbnailEnabled,
+                    liveStream: options.liveEnabled,
+                    monitorSelection: true,
+                    screenCount: 1,
+                    monitorCount: 1,
+                    control: false,
+                    audio: false,
+                    remoteAudio: false,
+                    fileTransfer: true,
+                    remoteFiles: true,
+                    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
+                }
+            });
+        });
 
         socket.on('data', chunk => {
             buffer += chunk;