@livedesk/client 0.1.123 → 0.1.124

package/bin/livedesk-client-node.js

@@ -18,8 +18,9 @@ const MAX_LIVE_FPS = 30;
 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;
+const MAX_FILE_TRANSFER_BYTES = 24 * 1024 * 1024;
+const MAX_AGENT_OUTPUT_CHARS = 32000;
+const launchedProcessRegistry = new Map();
 
 function printHelp() {
     console.log(`
@@ -888,21 +889,51 @@ function startLiveStream(socket, options, message, nextFrameSeq, activeStreams)
     return { streamId, fps, intervalMs };
 }
 
-function isSensitiveAgentPath(value) {
+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;
-}
+    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 isPathWithinAgentRoot(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+async function assertAgentPathDoesNotTraverseLink(base, resolved) {
+    await fs.mkdir(base, { recursive: true });
+    const canonicalRoot = await fs.realpath(base);
+    let current = resolved;
+    while (true) {
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new Error('Safe Agent paths cannot traverse symbolic links or junctions.');
+            }
+            const canonicalCurrent = await fs.realpath(current);
+            if (!isPathWithinAgentRoot(canonicalRoot, canonicalCurrent)) {
+                throw new Error('Safe Agent path resolves outside the LiveDesk files directory.');
+            }
+            return;
+        } catch (error) {
+            if (error?.code !== 'ENOENT') throw error;
+            const parent = path.dirname(current);
+            if (parent === current) throw new Error('Safe Agent path could not be verified.');
+            current = parent;
+        }
+    }
+}
+
+async 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 (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) {
     return new Promise((resolve, reject) => {
@@ -930,23 +961,111 @@ function redactAgentOutput(value) {
     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 '';
-}
+function normalizeNodeProcessKey(value) {
+    return path.basename(String(value || '').trim()).toLowerCase().replace(/\.(exe|bin)$/i, '');
+}
+
+function parseWindowsCommandLine(commandLine) {
+    const text = String(commandLine || '').trim();
+    const parsed = [];
+    let index = 0;
+    while (index < text.length) {
+        while (/\s/.test(text[index] || '')) index += 1;
+        if (index >= text.length) break;
+        let value = '';
+        let quoted = false;
+        while (index < text.length) {
+            const character = text[index];
+            if (character === '\\') {
+                let slashCount = 0;
+                while (text[index + slashCount] === '\\') slashCount += 1;
+                const next = text[index + slashCount];
+                if (next === '"') {
+                    value += '\\'.repeat(Math.floor(slashCount / 2));
+                    index += slashCount;
+                    if (slashCount % 2 === 1) {
+                        value += '"';
+                        index += 1;
+                    } else {
+                        quoted = !quoted;
+                        index += 1;
+                    }
+                } else {
+                    value += '\\'.repeat(slashCount);
+                    index += slashCount;
+                }
+                continue;
+            }
+            if (character === '"') {
+                quoted = !quoted;
+                index += 1;
+                continue;
+            }
+            if (/\s/.test(character) && !quoted) break;
+            value += character;
+            index += 1;
+        }
+        parsed.push(value);
+        while (/\s/.test(text[index] || '')) index += 1;
+    }
+    return parsed;
+}
+
+function decodeUtf16Base64(value) {
+    try {
+        return Buffer.from(String(value || ''), 'base64').toString('utf16le');
+    } catch {
+        return '';
+    }
+}
+
+function decodeNullSeparatedBase64(value) {
+    try {
+        return Buffer.from(String(value || ''), 'base64').toString('utf8');
+    } catch {
+        return '';
+    }
+}
+
+async function findNodeProcessDetails(processName) {
+    const name = String(processName || '').trim();
+    if (!name) return null;
+    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; if($p){ $bytes=[Text.Encoding]::Unicode.GetBytes([string]$p.CommandLine); [Console]::Out.WriteLine([string]$p.ProcessId); [Console]::Out.WriteLine([string]$p.ExecutablePath); [Console]::Out.Write([Convert]::ToBase64String($bytes)) }',
+            name
+        ], 10000);
+        if (result.exitCode !== 0) return null;
+        const lines = String(result.output || '').trim().split(/\r?\n/);
+        const executable = String(lines[1] || '').trim();
+        if (!lines[0] || !executable) return null;
+        const commandLine = decodeUtf16Base64(lines[2]);
+        const parsed = parseWindowsCommandLine(commandLine);
+        return { pid: Number(lines[0]) || 0, executable, args: parsed.length > 1 ? parsed.slice(1) : null, workingDirectory: null, metadataSource: 'process-command-line' };
+    }
+    if (process.platform === 'linux') {
+        const result = await runNodeAgentProcess('/bin/sh', ['-lc', 'pid=$(pgrep -xo -- "$1" || true); if [ -n "$pid" ] && [ -e "/proc/$pid/exe" ]; then printf "%s\\n%s\\n%s\\n" "$pid" "$(readlink -f "/proc/$pid/exe")" "$(readlink -f "/proc/$pid/cwd")"; base64 -w0 "/proc/$pid/cmdline"; fi', 'livedesk-process-details', name], 10000);
+        if (result.exitCode !== 0) return null;
+        const lines = String(result.output || '').trim().split(/\r?\n/);
+        const executable = String(lines[1] || '').trim();
+        const workingDirectory = String(lines[2] || '').trim();
+        if (!lines[0] || !executable) return null;
+        const parsed = decodeNullSeparatedBase64(lines[3]).split('\0').filter(Boolean);
+        return { pid: Number(lines[0]) || 0, executable, args: parsed.length > 1 ? parsed.slice(1) : null, workingDirectory: workingDirectory || null, metadataSource: 'proc' };
+    }
+    if (process.platform === 'darwin') {
+        const result = await runNodeAgentProcess('/bin/sh', ['-lc', 'pid=$(pgrep -xo -- "$1" || true); if [ -n "$pid" ]; then exe=$(ps -p "$pid" -o comm= | sed "s/^ *//"); cwd=$(lsof -a -p "$pid" -d cwd -Fn 2>/dev/null | sed -n "s/^n//p" | head -n 1); command=$(ps -p "$pid" -o command=); printf "%s\\n%s\\n%s\\n" "$pid" "$exe" "$cwd"; printf "%s" "$command" | base64 | tr -d "\\n"; fi', 'livedesk-process-details', name], 10000);
+        if (result.exitCode !== 0) return null;
+        const lines = String(result.output || '').trim().split(/\r?\n/);
+        const executable = String(lines[1] || '').trim();
+        const workingDirectory = String(lines[2] || '').trim();
+        if (!lines[0] || !executable) return null;
+        const parsed = parseWindowsCommandLine(Buffer.from(String(lines[3] || ''), 'base64').toString('utf8'));
+        return { pid: Number(lines[0]) || 0, executable, args: parsed.length > 1 ? parsed.slice(1) : null, workingDirectory: workingDirectory || null, metadataSource: 'ps-lsof' };
+    }
+    return null;
+}
 
 async function persistNodeEnvironmentVariable(name, value) {
     const variableName = String(name || '').trim();
@@ -972,31 +1091,34 @@ async function persistNodeEnvironmentVariable(name, value) {
 
 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 args = payload.toolArguments && typeof payload.toolArguments === 'object' ? payload.toolArguments : payload;
+    if (operation === 'file.read') {
+        const filePath = await 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');
+    }
+    if (operation === 'file.write') {
+        let filePath = await 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 });
+        // Re-check after creating missing parents so a newly introduced link
+        // cannot turn the write into an outside-root operation.
+        filePath = await resolveAgentPath(options, args.path, permissionMode);
+        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 (operation === 'file.delete') {
+        const filePath = await 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);
+    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));
         const data = [];
@@ -1006,26 +1128,36 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
             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 } };
-        }
+    }
+    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 launchArgs = Array.isArray(args.args) ? args.args.slice(0, 32).map(String) : [];
+        const workingDirectory = args.workingDirectory ? await resolveAgentPath(options, args.workingDirectory, permissionMode, false) : process.cwd();
+        const child = spawn(executable, launchArgs, { cwd: workingDirectory, detached: true, windowsHide: true, stdio: 'ignore' });
+        child.unref();
+        launchedProcessRegistry.set(normalizeNodeProcessKey(executable), { executable, args: launchArgs, workingDirectory, metadataSource: 'launch_application' });
+        return { summary: `Started ${path.basename(executable)}.`, data: { executable, args: launchArgs, workingDirectory, pid: child.pid } };
+    }
+    if (operation === 'process.control') {
+        const action = String(args.action || 'stop');
+        const processName = String(args.processName || '').trim();
+        const processDetails = await findNodeProcessDetails(processName);
+        if (!processDetails) {
+            if (action === 'restart') throw new Error(`process-not-found: ${processName}`);
+            return { summary: `${processName} is already stopped.`, data: { action, processName, status: 'already-stopped', ok: true } };
+        }
+        if (action === 'restart') {
+            const restartMetadata = launchedProcessRegistry.get(normalizeNodeProcessKey(processName)) || processDetails;
+            if (!restartMetadata.executable || !Array.isArray(restartMetadata.args) || !restartMetadata.workingDirectory) {
+                throw new Error(`process-restart-metadata-unavailable: ${processName}`);
+            }
+            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(restartMetadata.executable, restartMetadata.args, { cwd: restartMetadata.workingDirectory, detached: true, windowsHide: true, stdio: 'ignore' });
+            child.unref();
+            return { summary: `Restarted ${processName}.`, data: { action, processName, stop, restarted: true, pid: child.pid, executable: restartMetadata.executable, args: restartMetadata.args, workingDirectory: restartMetadata.workingDirectory, metadataSource: restartMetadata.metadataSource } };
+        }
         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 } };
     }
@@ -1054,11 +1186,11 @@ async function executeNodeAgentOperation(options, operation, payload = {}) {
         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);
+        const result = await runNodeAgentProcess(executable, commandArgs, args.timeoutMs, args.workingDirectory ? await 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 scriptPath = await 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);

package/package.json

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