@livedesk/client 0.1.120 → 0.1.122

package/THIRD_PARTY_NOTICES.md

@@ -24,4 +24,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

package/bin/livedesk-client-node.js

@@ -5,6 +5,7 @@ import os from 'os';
 import path from 'path';
 import crypto from 'crypto';
 import { promises as fs, statfsSync } from 'fs';
+import { spawn } from 'child_process';
 
 const AGENT_VERSION = '0.1.24-livedesk.1';
 const DEFAULT_MANAGER = '127.0.0.1:5197';
@@ -18,6 +19,7 @@ const MAX_FRAME_BASE64_CHARS = 3 * 1024 * 1024;
 const MAX_AI_OUTPUT_CHARS = 6000;
 const MAX_FILE_TRANSFER_FILES = 24;
 const MAX_FILE_TRANSFER_BYTES = 24 * 1024 * 1024;
+const MAX_AGENT_OUTPUT_CHARS = 32000;
 
 function printHelp() {
     console.log(`
@@ -868,6 +870,233 @@ function startLiveStream(socket, options, message, nextFrameSeq, activeStreams)
     return { streamId, fps, intervalMs };
 }
 
+function isSensitiveAgentPath(value) {
+    const normalized = String(value || '').replaceAll('\\', '/').toLowerCase();
+    return normalized.includes('/.codex/') || normalized.endsWith('/auth.json') || normalized.includes('/.ssh/') || normalized.includes('/id_rsa') || normalized.endsWith('.pem') || normalized.endsWith('.key') || normalized.endsWith('/.env') || normalized.includes('/credential') || normalized.includes('/secret') || normalized.includes('/password');
+}
+
+function resolveAgentPath(options, value, permissionMode, rejectSensitive = true) {
+    const base = normalizeDirectoryPath(options.filesDir || undefined);
+    const text = String(value || '').replace(/\0/g, '').trim();
+    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 (rejectSensitive && isSensitiveAgentPath(resolved)) throw new Error('credential and secret paths are not available');
+    return resolved;
+}
+
+function runNodeAgentProcess(executable, args, timeoutMs = 15000, cwd = undefined) {
+    return new Promise((resolve, reject) => {
+        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); };
+        child.stdout.on('data', append);
+        child.stderr.on('data', append);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => child.kill('SIGKILL'), 1000).unref?.();
+        }, Math.max(1000, Math.min(30000, 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 }); });
+    });
+}
+
+function redactAgentOutput(value) {
+    let output = String(value || '').replace(/[\0\r]/g, ' ');
+    output = output.replace(/\b(token|secret|password|api[-_]?key|authorization|private[-_]?key|connection[-_]?string|access[-_]?key|client[-_]?secret)\b\s*[:=]\s*("[^"]*"|'[^']*'|[^\s,;]+)/gi, '$1=[redacted]');
+    output = output.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [redacted]');
+    output = output.replace(/^(\s*(?:set\s+)?(?:[A-Z_][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|KEY|AUTH|CREDENTIAL|CONNECTION)[A-Z0-9_]*)\s*=\s*).+$/gim, '$1[redacted]');
+    return output.slice(0, MAX_AGENT_OUTPUT_CHARS);
+}
+
+async function findNodeProcessExecutable(processName) {
+    const name = String(processName || '').trim();
+    if (!name) return '';
+    if (process.platform === 'win32') {
+        const result = await runNodeAgentProcess('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-Command',
+            '$name=$args[0]; $p=Get-CimInstance Win32_Process | Where-Object { $_.Name -ieq $name } | Select-Object -First 1 -ExpandProperty ExecutablePath; if($p){[Console]::Out.Write($p)}',
+            name
+        ], 10000);
+        return result.exitCode === 0 ? String(result.output || '').trim().split(/\r?\n/)[0] : '';
+    }
+    if (process.platform === 'linux') {
+        const result = await runNodeAgentProcess('/bin/sh', ['-lc', 'pid=$(pgrep -xo -- "$1" || true); if [ -n "$pid" ] && [ -e "/proc/$pid/exe" ]; then readlink -f "/proc/$pid/exe"; fi', 'livedesk-process-path', name], 10000);
+        return result.exitCode === 0 ? String(result.output || '').trim().split(/\r?\n/)[0] : '';
+    }
+    return '';
+}
+
+async function persistNodeEnvironmentVariable(name, value) {
+    const variableName = String(name || '').trim();
+    const variableValue = String(value ?? '');
+    if (process.platform === 'win32') {
+        const result = await runNodeAgentProcess('setx.exe', [variableName, variableValue], 15000);
+        if (result.exitCode !== 0 || result.timedOut) throw new Error(`Persistent environment update failed (exit ${result.exitCode}).`);
+        process.env[variableName] = variableValue;
+        return { persisted: true, scope: 'user', output: result.output };
+    }
+    const profilePath = path.join(os.homedir(), '.profile');
+    const marker = `# LiveDesk managed environment: ${variableName}`;
+    const quoted = `'${variableValue.replaceAll("'", "'\\\"'\\\"'")}'`;
+    let profile = '';
+    try { profile = await fs.readFile(profilePath, 'utf8'); } catch { /* create on demand */ }
+    const lines = profile.split(/\r?\n/).filter(line => !line.includes(marker));
+    while (lines.length && lines[lines.length - 1] === '') lines.pop();
+    lines.push(marker, `export ${variableName}=${quoted}`);
+    await fs.writeFile(profilePath, `${lines.join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+    process.env[variableName] = variableValue;
+    return { persisted: true, scope: 'user-profile', path: profilePath };
+}
+
+async function executeNodeAgentOperation(options, operation, payload = {}) {
+    const permissionMode = String(payload.permissionMode || 'ask');
+    const args = payload.toolArguments && typeof payload.toolArguments === 'object' ? payload.toolArguments : payload;
+    if (operation === 'file.read') {
+        const filePath = resolveAgentPath(options, args.path, permissionMode);
+        const info = await fs.stat(filePath);
+        const maxBytes = Math.max(1, Math.min(65536, Number(args.maxBytes) || 65536));
+        const content = (await fs.readFile(filePath)).subarray(0, maxBytes).toString('utf8');
+        return { summary: `Read ${Buffer.byteLength(content)} bytes from ${path.basename(filePath)}.`, data: { path: filePath, sizeBytes: info.size, returnedBytes: Buffer.byteLength(content), truncated: info.size > Buffer.byteLength(content), content } };
+    }
+    if (operation === 'file.write') {
+        const filePath = resolveAgentPath(options, args.path, permissionMode);
+        const content = String(args.content || '');
+        if (Buffer.byteLength(content) > 1048576) throw new Error('file content exceeds the 1 MiB limit');
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        if (args.append === true) await fs.appendFile(filePath, content, 'utf8');
+        else await fs.writeFile(filePath, content, 'utf8');
+        return { summary: `Wrote ${Buffer.byteLength(content)} bytes to ${path.basename(filePath)}.`, data: { path: filePath, sizeBytes: (await fs.stat(filePath)).size, append: args.append === true } };
+    }
+    if (operation === 'file.delete') {
+        const filePath = resolveAgentPath(options, args.path, permissionMode);
+        if (args.recursive === true) await fs.rm(filePath, { recursive: true, force: false });
+        else await fs.unlink(filePath);
+        return { summary: `Deleted ${path.basename(filePath)}.`, data: { path: filePath, recursive: args.recursive === true } };
+    }
+    if (operation === 'file.list') {
+        const directory = 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));
+        const data = [];
+        for (const entry of entries.slice(0, maxEntries)) {
+            const entryPath = path.join(directory, entry.name);
+            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 === 'application.launch') {
+        const executable = String(args.executable || '').trim();
+        if (!executable || executable.length > 400 || /[\0\r\n]/.test(executable)) throw new Error('executable is invalid');
+        const child = spawn(executable, Array.isArray(args.args) ? args.args.slice(0, 32).map(String) : [], { cwd: args.workingDirectory ? resolveAgentPath(options, args.workingDirectory, permissionMode, false) : undefined, detached: true, windowsHide: true, stdio: 'ignore' });
+        child.unref();
+        return { summary: `Started ${path.basename(executable)}.`, data: { executable, pid: child.pid } };
+    }
+    if (operation === 'process.control') {
+        const action = String(args.action || 'stop');
+        const processName = String(args.processName || '').trim();
+        if (action === 'restart') {
+            const executable = await findNodeProcessExecutable(processName);
+            if (!executable) throw new Error(`Restart is not supported because the executable path for ${processName} could not be resolved.`);
+            const stop = await runNodeAgentProcess(process.platform === 'win32' ? 'taskkill' : 'pkill', process.platform === 'win32' ? ['/IM', processName, '/T', '/F'] : ['-TERM', processName]);
+            if (stop.exitCode !== 0 && !stop.timedOut) throw new Error(`Process stop failed before restart (exit ${stop.exitCode}).`);
+            const child = spawn(executable, [], { detached: true, windowsHide: true, stdio: 'ignore' });
+            child.unref();
+            return { summary: `Restarted ${processName}.`, data: { action, processName, stop, restarted: true, pid: child.pid, executable } };
+        }
+        const result = await runNodeAgentProcess(process.platform === 'win32' ? 'taskkill' : 'pkill', process.platform === 'win32' ? ['/IM', processName, '/T'] : ['-TERM', processName]);
+        return { summary: `${action} requested for ${processName}.`, data: { action, processName, ...result } };
+    }
+    if (operation === 'application.close') return executeNodeAgentOperation(options, 'process.control', { ...payload, toolArguments: { ...args, action: 'stop' } });
+    if (operation === 'service.control') {
+        const service = String(args.serviceName || '');
+        const action = String(args.action || 'status');
+        const executable = process.platform === 'win32' ? 'sc.exe' : 'systemctl';
+        const actions = action === 'restart' ? ['stop', 'start'] : [action];
+        const results = [];
+        for (const step of actions) {
+            const result = await runNodeAgentProcess(executable, [step, service]);
+            results.push({ action: step, ...result });
+            if (result.exitCode !== 0 || result.timedOut) break;
+        }
+        const ok = results.length === actions.length && results.every(result => result.exitCode === 0 && !result.timedOut);
+        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 || '');
+        const executable = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+        const commandArgs = process.platform === 'win32' ? ['/d', '/s', '/c', command] : ['-lc', command];
+        const result = await runNodeAgentProcess(executable, commandArgs, args.timeoutMs, args.workingDirectory ? resolveAgentPath(options, args.workingDirectory, permissionMode, false) : undefined);
+        return { summary: result.timedOut ? 'Command timed out.' : `Command exited with code ${result.exitCode}.`, data: { ...result, output: redactAgentOutput(result.output) } };
+    }
+    if (operation === 'script.run') {
+        const scriptPath = resolveAgentPath(options, args.path, permissionMode);
+        const executable = process.platform === 'win32' ? 'powershell.exe' : '/bin/sh';
+        const scriptArgs = process.platform === 'win32' ? ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, ...(Array.isArray(args.args) ? args.args.slice(0, 32).map(String) : [])] : [scriptPath, ...(Array.isArray(args.args) ? args.args.slice(0, 32).map(String) : [])];
+        const result = await runNodeAgentProcess(executable, scriptArgs, args.timeoutMs);
+        return { summary: result.timedOut ? 'Script timed out.' : `Script exited with code ${result.exitCode}.`, data: { ...result, output: redactAgentOutput(result.output) } };
+    }
+    if (operation === 'software.install') {
+        const manager = String(args.manager || '').toLowerCase();
+        const packageName = String(args.packageName || '');
+        if (!/^[A-Za-z0-9._@:+/-]{1,200}$/.test(packageName)) throw new Error('packageName contains unsupported characters');
+        const commands = { winget: ['winget.exe', ['install', '--id', packageName, '--silent', '--accept-source-agreements', '--accept-package-agreements']], brew: ['brew', ['install', packageName]], apt: ['apt-get', ['install', '-y', packageName]], npm: ['npm', ['install', '--global', args.version ? `${packageName}@${args.version}` : packageName]] };
+        if (!commands[manager]) throw new Error('unsupported package manager');
+        const [executable, commandArgs] = commands[manager];
+        const result = await runNodeAgentProcess(executable, commandArgs, 30000);
+        return { summary: `Package install exited with code ${result.exitCode}.`, data: { manager, packageName, ...result } };
+    }
+    if (operation === 'network.status') return { summary: 'Network status collected.', data: Object.fromEntries(Object.entries(os.networkInterfaces()).map(([name, values]) => [name, (values || []).map(value => ({ address: value.address, family: value.family, internal: value.internal }))])) };
+    if (operation === 'system.power') {
+        const action = String(args.action || '');
+        const delaySec = String(Math.max(0, Math.min(3600, Number(args.delaySec) || 0)));
+        let executable;
+        let powerArgs;
+        if (process.platform === 'win32') {
+            ({ executable, args: powerArgs } = {
+                lock: { executable: 'rundll32.exe', args: ['user32.dll,LockWorkStation'] },
+                sleep: { executable: 'rundll32.exe', args: ['powrprof.dll,SetSuspendState', '0,1,0'] },
+                logoff: { executable: 'shutdown.exe', args: ['/l'] },
+                restart: { executable: 'shutdown.exe', args: ['/r', '/t', delaySec] },
+                shutdown: { executable: 'shutdown.exe', args: ['/s', '/t', delaySec] }
+            }[action] || {});
+        } else {
+            ({ executable, args: powerArgs } = {
+                lock: { executable: 'loginctl', args: ['lock-session'] },
+                sleep: { executable: 'systemctl', args: ['suspend'] },
+                logoff: { executable: 'loginctl', args: ['terminate-user', os.userInfo().username] },
+                restart: { executable: 'systemctl', args: ['reboot'] },
+                shutdown: { executable: 'systemctl', args: ['poweroff'] }
+            }[action] || {});
+        }
+        if (!executable) throw new Error(`Unsupported power action: ${action}.`);
+        const result = await runNodeAgentProcess(executable, powerArgs, 15000);
+        return { summary: `Power action ${action} requested.`, data: result };
+    }
+    if (operation === 'system.configure') {
+        if (args.action === 'set-environment-variable') {
+            if (!/^[A-Za-z_][A-Za-z0-9_]{0,119}$/.test(String(args.name || '')) || /^(PATH|PATHEXT|SYSTEMROOT|WINDIR|COMSPEC)$/i.test(String(args.name))) throw new Error('environment variable name is not allowed');
+            const persistence = await persistNodeEnvironmentVariable(String(args.name), String(args.value ?? ''));
+            return { summary: `Environment variable ${args.name} was persisted.`, data: { action: args.action, name: args.name, changed: true, ...persistence } };
+        }
+        const result = await runNodeAgentProcess(process.platform === 'win32' ? 'tzutil.exe' : 'timedatectl', process.platform === 'win32' ? ['/s', String(args.value || '')] : ['set-timezone', String(args.value || '')]);
+        return { summary: `Timezone update exited with code ${result.exitCode}.`, data: result };
+    }
+    if (operation === 'logs.collect') {
+        const maxLines = Math.max(1, Math.min(500, Number(args.maxLines) || 100));
+        const result = await runNodeAgentProcess(process.platform === 'win32' ? 'powershell.exe' : 'journalctl', process.platform === 'win32' ? ['-NoProfile', '-NonInteractive', '-Command', `Get-WinEvent -LogName System -MaxEvents ${maxLines} | Format-List`] : ['-n', String(maxLines), '--no-pager', '-o', 'short']);
+        return { summary: 'Recent logs collected.', data: { source: args.source || 'system', ...result, output: result.output.replace(/(token|password|secret|api[-_]?key|authorization)\s*[:=]\s*[^\s]+/gi, '$1=[redacted]') } };
+    }
+    throw new Error(`Unsupported command: ${operation}`);
+}
+
+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']);
+
 async function handleRemoteCommand(socket, options, message, nextFrameSeq, activeStreams) {
     const command = String(message.command || '');
     if (command === 'ping') {
@@ -882,6 +1111,33 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
         return;
     }
 
+    if (NODE_AGENT_OPERATIONS.has(command)) {
+        if (!options.taskEnabled) {
+            writeJsonLine(socket, { type: 'command.result', commandId: message.commandId, error: 'remote task capability is disabled' });
+            return;
+        }
+        try {
+            const result = await executeNodeAgentOperation(options, command, message.payload || {});
+            writeJsonLine(socket, {
+                type: 'command.result',
+                commandId: message.commandId,
+                result: {
+                    kind: command,
+                    mode: String(message.payload?.permissionMode || 'ask'),
+                    taskId: String(message.payload?.taskId || '').slice(0, 128),
+                    status: 'completed',
+                    summary: result.summary,
+                    data: result.data,
+                    sideEffects: ['file.read', 'file.list', 'network.status', 'logs.collect'].includes(command) ? 'none' : 'audited',
+                    completedAt: new Date().toISOString()
+                }
+            });
+        } catch (error) {
+            writeJsonLine(socket, { type: 'command.result', commandId: message.commandId, error: error?.message || String(error) });
+        }
+        return;
+    }
+
     if (command === 'agent.task') {
         if (!options.taskEnabled) {
             writeJsonLine(socket, {
@@ -1178,10 +1434,14 @@ function connectOnce(options, deviceId) {
                     fileTransferMaxBytes: MAX_FILE_TRANSFER_BYTES,
                     computerAgent: options.taskEnabled,
                     taskDispatch: options.taskEnabled,
+                    agentApproval: options.taskEnabled,
+                    agentAudit: options.taskEnabled,
+                    agentTools: [...NODE_AGENT_OPERATIONS],
+                    elevation: typeof process.getuid === 'function' ? process.getuid() === 0 : false,
                     aiAssist: options.taskEnabled && options.aiEnabled && (options.fakeAi || !!options.openAiApiKey),
                     aiModel: options.aiModel,
                     aiProvider: options.fakeAi ? 'fake' : (options.openAiApiKey ? 'openai' : ''),
-                    externalEffects: false
+                    externalEffects: options.taskEnabled
                 }
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.120",
+  "version": "0.1.122",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {