@livedesk/client 0.1.249 → 0.1.251

package/bin/livedesk-client-node.js

@@ -7,7 +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 { fileURLToPath } from 'node:url';
+import { resolveAgentShellCommand } from '../src/runtime/agent-shell.js';
 
 const require = createRequire(import.meta.url);
 const CLIENT_UPDATE_BOOTSTRAP_PATH = fileURLToPath(
@@ -1142,9 +1143,10 @@ async function resolveAgentPath(options, value, permissionMode, rejectSensitive
     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'] });
+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); };
@@ -1154,11 +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(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 }); });
-    });
-}
+        }, 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, ' ');
@@ -1324,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));
@@ -1334,8 +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 } };
-    }
+        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');
@@ -1389,12 +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 || '');
-        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 ? 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 === '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);
@@ -1481,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', '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;
@@ -1723,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', '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()
                 }
             });

package/bin/livedesk-client.js

@@ -19,8 +19,8 @@ import {
     signalAgentTree
 } from '../src/runtime/agent-process-lifecycle.js';
 import { writeWindowsOwnedProcessManifest } from '../src/runtime/windows-owned-process-manifest.js';
-import { createHubWakeListener } from '../src/runtime/hub-wake-listener.js';
-import { resolveSpawnablePackagedPath } from '../src/runtime/packaged-executable-path.js';
+import { createHubWakeListener } from '../src/runtime/hub-wake-listener.js';
+import { resolveSpawnablePackagedPath } from '../src/runtime/packaged-executable-path.js';
 import {
     inspectLinuxVideoAcceleration,
     installLinuxVideoAcceleration
@@ -588,7 +588,7 @@ export function resolveHubClientPort(env = process.env) {
     return normalizePort(env.REMOTE_HUB_PORT || env.LIVEDESK_HUB_REMOTE_PORT) || DEFAULT_HUB_CLIENT_PORT;
 }
 
-export function preflightHubClientPort(port = resolveHubClientPort()) {
+export function preflightHubClientPort(port = resolveHubClientPort()) {
     const normalizedPort = normalizePort(port);
     if (!normalizedPort) {
         return Promise.resolve({ ok: false, port: Number(port) || 0, code: 'invalid-hub-client-port' });
@@ -618,46 +618,46 @@ export function preflightHubClientPort(port = resolveHubClientPort()) {
                 finish({ ok: true, code: 'ok' });
             });
         });
-    });
-}
-
-export async function recoverHubClientPortConflict(preflight, recoverPortOwner) {
-    if (preflight?.ok
-        || preflight?.code !== 'hub-client-port-in-use'
-        || typeof recoverPortOwner !== 'function') {
-        return preflight;
-    }
-
-    try {
-        await recoverPortOwner(Number(preflight.port || resolveHubClientPort()));
-    } catch (error) {
-        return {
-            ...preflight,
-            recoveryAttempted: true,
-            recoveryError: error instanceof Error ? error.message : String(error)
-        };
-    }
-
-    const verified = await preflightHubClientPort(preflight.port);
-    return {
-        ...verified,
-        recoveryAttempted: true,
-        recovered: verified.ok === true
-    };
-}
-
-function hubClientPortPreflightError(preflight) {
-    const port = Number(preflight?.port || resolveHubClientPort());
-    const recoveryError = String(preflight?.recoveryError || '').trim();
-    return {
-        ok: false,
-        code: String(preflight?.code || 'hub-client-port-unavailable'),
-        port,
-        error: recoveryError
-            ? `${recoveryError} The current Hub was not changed.`
-            : preflight?.code === 'hub-client-port-in-use'
-            ? `LiveDesk cannot switch this computer to Hub because TCP ${port} is already in use. Change or stop the owning service, then try Switch to Hub again. The current Hub was not changed.`
-            : `LiveDesk cannot switch this computer to Hub because TCP ${port} is unavailable. Check the local port configuration, then try again. The current Hub was not changed.`
+    });
+}
+
+export async function recoverHubClientPortConflict(preflight, recoverPortOwner) {
+    if (preflight?.ok
+        || preflight?.code !== 'hub-client-port-in-use'
+        || typeof recoverPortOwner !== 'function') {
+        return preflight;
+    }
+
+    try {
+        await recoverPortOwner(Number(preflight.port || resolveHubClientPort()));
+    } catch (error) {
+        return {
+            ...preflight,
+            recoveryAttempted: true,
+            recoveryError: error instanceof Error ? error.message : String(error)
+        };
+    }
+
+    const verified = await preflightHubClientPort(preflight.port);
+    return {
+        ...verified,
+        recoveryAttempted: true,
+        recovered: verified.ok === true
+    };
+}
+
+function hubClientPortPreflightError(preflight) {
+    const port = Number(preflight?.port || resolveHubClientPort());
+    const recoveryError = String(preflight?.recoveryError || '').trim();
+    return {
+        ok: false,
+        code: String(preflight?.code || 'hub-client-port-unavailable'),
+        port,
+        error: recoveryError
+            ? `${recoveryError} The current Hub was not changed.`
+            : preflight?.code === 'hub-client-port-in-use'
+            ? `LiveDesk cannot switch this computer to Hub because TCP ${port} is already in use. Change or stop the owning service, then try Switch to Hub again. The current Hub was not changed.`
+            : `LiveDesk cannot switch this computer to Hub because TCP ${port} is unavailable. Check the local port configuration, then try again. The current Hub was not changed.`
     };
 }
 
@@ -3110,16 +3110,16 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                         res.end(JSON.stringify({ ok: false, error: 'client-can-only-transition-to-hub' }));
                         return;
                     }
-                    const portPreflight = await preflightHubClientPort();
-                    const readyPortPreflight = await recoverHubClientPortConflict(
-                        portPreflight,
-                        options.recoverHubClientPort
-                    );
-                    if (!readyPortPreflight.ok) {
-                        res.writeHead(409, { 'Content-Type': 'application/json; charset=utf-8', 'Access-Control-Allow-Origin': '*' });
-                        res.end(JSON.stringify(hubClientPortPreflightError(readyPortPreflight)));
-                        return;
-                    }
+                    const portPreflight = await preflightHubClientPort();
+                    const readyPortPreflight = await recoverHubClientPortConflict(
+                        portPreflight,
+                        options.recoverHubClientPort
+                    );
+                    if (!readyPortPreflight.ok) {
+                        res.writeHead(409, { 'Content-Type': 'application/json; charset=utf-8', 'Access-Control-Allow-Origin': '*' });
+                        res.end(JSON.stringify(hubClientPortPreflightError(readyPortPreflight)));
+                        return;
+                    }
                     const session = await refreshSessionIfNeeded(supabase);
                     const expectedRoleVersion = Number(dashboardState.roleVersion || 0);
                     const { data, error } = await supabase.rpc('set_livedesk_device_role', {
@@ -3435,14 +3435,14 @@ async function chooseClientConnection(supabase, options = {}) {
                 if (!activeSupabase) {
                     return { ok: false, error: 'supabase-session-required' };
                 }
-                const portPreflight = await preflightHubClientPort();
-                const readyPortPreflight = await recoverHubClientPortConflict(
-                    portPreflight,
-                    options.recoverHubClientPort
-                );
-                if (!readyPortPreflight.ok) {
-                    return hubClientPortPreflightError(readyPortPreflight);
-                }
+                const portPreflight = await preflightHubClientPort();
+                const readyPortPreflight = await recoverHubClientPortConflict(
+                    portPreflight,
+                    options.recoverHubClientPort
+                );
+                if (!readyPortPreflight.ok) {
+                    return hubClientPortPreflightError(readyPortPreflight);
+                }
                 const session = await refreshSessionIfNeeded(activeSupabase);
                 if (!session?.access_token) {
                     return { ok: false, error: 'supabase-session-required' };
@@ -4465,14 +4465,14 @@ function getFastRuntime() {
     const arch = os.arch();
     const resolvePackagedRuntime = (packageName, rid, executableName) => {
         try {
-            const packagePath = require.resolve(`${packageName}/package.json`);
-            const fastRoot = join(dirname(packagePath), 'fast');
-            return {
-                rid,
-                packageName,
-                executable: resolveSpawnablePackagedPath(join(fastRoot, executableName)),
-                dll: resolveSpawnablePackagedPath(join(fastRoot, 'livedesk-client-fast.dll'))
-            };
+            const packagePath = require.resolve(`${packageName}/package.json`);
+            const fastRoot = join(dirname(packagePath), 'fast');
+            return {
+                rid,
+                packageName,
+                executable: resolveSpawnablePackagedPath(join(fastRoot, executableName)),
+                dll: resolveSpawnablePackagedPath(join(fastRoot, 'livedesk-client-fast.dll'))
+            };
         } catch {
             return {
                 rid,
@@ -4607,15 +4607,15 @@ function clearFastPreflightCache() {
     }
 }
 
-function resolveBundledFfmpegPaths() {
-    const paths = [];
-    const addPath = (candidate) => {
-        // Electron can resolve ffmpeg-static through app.asar, but RemoteFast
-        // is a native process and must receive the physical unpacked path.
-        const ffmpegPath = resolveSpawnablePackagedPath(String(candidate || '').trim());
-        if (ffmpegPath && existsSync(ffmpegPath) && !paths.includes(ffmpegPath)) {
-            paths.push(ffmpegPath);
-        }
+function resolveBundledFfmpegPaths() {
+    const paths = [];
+    const addPath = (candidate) => {
+        // Electron can resolve ffmpeg-static through app.asar, but RemoteFast
+        // is a native process and must receive the physical unpacked path.
+        const ffmpegPath = resolveSpawnablePackagedPath(String(candidate || '').trim());
+        if (ffmpegPath && existsSync(ffmpegPath) && !paths.includes(ffmpegPath)) {
+            paths.push(ffmpegPath);
+        }
     };
 
     const addFfmpegInstaller = () => {
@@ -5121,10 +5121,10 @@ export async function runClientRuntime(argv = process.argv.slice(2), runtimeOpti
             savedSession: null,
             loadSavedSession: false,
             savedPin: null,
-            allowRelayFallback: transportAllowsRelay(parsed.transport),
-            relayEndpoint: parsed.relay,
-            recoverHubClientPort: runtimeOptions.recoverHubClientPort,
-            openBrowser: parsed.openBrowserOnStart,
+            allowRelayFallback: transportAllowsRelay(parsed.transport),
+            relayEndpoint: parsed.relay,
+            recoverHubClientPort: runtimeOptions.recoverHubClientPort,
+            openBrowser: parsed.openBrowserOnStart,
             onStarted: page => {
                 connectionPage = page;
                 resolveStarted(page);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.249",
+  "version": "0.1.251",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -42,10 +42,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.445",
-    "@livedesk/fast-osx-arm64": "0.1.445",
-    "@livedesk/fast-osx-x64": "0.1.445",
-    "@livedesk/fast-win-x64": "0.1.445"
+    "@livedesk/fast-linux-x64": "0.1.447",
+    "@livedesk/fast-osx-arm64": "0.1.447",
+    "@livedesk/fast-osx-x64": "0.1.447",
+    "@livedesk/fast-win-x64": "0.1.447"
   },
   "publishConfig": {
     "access": "public"

package/src/runtime/agent-shell.js

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs';
+
+export const AGENT_SHELL_NAMES = Object.freeze([
+    'auto',
+    'powershell',
+    'pwsh',
+    'cmd',
+    'sh',
+    'bash',
+    'zsh'
+]);
+
+function unixShellPath(shell, platform, fileExists) {
+    if (shell === 'sh') return '/bin/sh';
+    if (shell === 'bash') return '/bin/bash';
+    if (shell === 'zsh') return '/bin/zsh';
+    if (shell === 'pwsh') return 'pwsh';
+    if (shell === 'powershell' || shell === 'cmd') {
+        throw new Error(`${shell} is not available on ${platform}.`);
+    }
+    if (platform === 'darwin' && fileExists('/bin/zsh')) return '/bin/zsh';
+    if (fileExists('/bin/bash')) return '/bin/bash';
+    return '/bin/sh';
+}
+
+export function resolveAgentShellCommand({
+    platform = process.platform,
+    shell = 'auto',
+    command = '',
+    fileExists = existsSync
+} = {}) {
+    const normalizedShell = String(shell || 'auto').trim().toLowerCase();
+    if (!AGENT_SHELL_NAMES.includes(normalizedShell)) {
+        throw new Error(`Unsupported shell: ${normalizedShell || 'empty'}.`);
+    }
+    if (platform === 'win32') {
+        if (['sh', 'bash', 'zsh'].includes(normalizedShell)) {
+            throw new Error(`${normalizedShell} is not available on Windows.`);
+        }
+        if (normalizedShell === 'cmd') {
+            return {
+                shell: 'cmd',
+                executable: process.env.ComSpec || 'cmd.exe',
+                args: ['/d', '/s', '/c', String(command)]
+            };
+        }
+        const powershellCore = normalizedShell === 'pwsh';
+        return {
+            shell: powershellCore ? 'pwsh' : 'powershell',
+            executable: powershellCore ? 'pwsh.exe' : 'powershell.exe',
+            args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', String(command)]
+        };
+    }
+
+    const executable = unixShellPath(normalizedShell, platform, fileExists);
+    if (executable.startsWith('/') && !fileExists(executable)) {
+        throw new Error(`${normalizedShell} is not installed at ${executable}.`);
+    }
+    return {
+        shell: normalizedShell === 'auto'
+            ? executable.endsWith('/zsh') ? 'zsh' : executable.endsWith('/bash') ? 'bash' : 'sh'
+            : normalizedShell,
+        executable,
+        args: ['-lc', String(command)]
+    };
+}

package/src/runtime/packaged-executable-path.js

@@ -1,23 +1,23 @@
-import { existsSync } from 'node:fs';
-
-const ASAR_PATH_SEGMENT = /([\\/])app\.asar([\\/])/i;
-
-/**
- * Electron's Node loader can read JavaScript through the virtual app.asar
- * path, but the operating system cannot spawn an executable from that virtual
- * archive. electron-builder places executable payloads in the matching
- * app.asar.unpacked tree, so only spawn targets cross that boundary.
- */
-export function resolveSpawnablePackagedPath(value, pathExists = existsSync) {
-    const candidate = String(value || '');
-    if (!candidate || !ASAR_PATH_SEGMENT.test(candidate)) {
-        return candidate;
-    }
-
-    const unpacked = candidate.replace(ASAR_PATH_SEGMENT, '$1app.asar.unpacked$2');
-    try {
-        return pathExists(unpacked) ? unpacked : candidate;
-    } catch {
-        return candidate;
-    }
-}
+import { existsSync } from 'node:fs';
+
+const ASAR_PATH_SEGMENT = /([\\/])app\.asar([\\/])/i;
+
+/**
+ * Electron's Node loader can read JavaScript through the virtual app.asar
+ * path, but the operating system cannot spawn an executable from that virtual
+ * archive. electron-builder places executable payloads in the matching
+ * app.asar.unpacked tree, so only spawn targets cross that boundary.
+ */
+export function resolveSpawnablePackagedPath(value, pathExists = existsSync) {
+    const candidate = String(value || '');
+    if (!candidate || !ASAR_PATH_SEGMENT.test(candidate)) {
+        return candidate;
+    }
+
+    const unpacked = candidate.replace(ASAR_PATH_SEGMENT, '$1app.asar.unpacked$2');
+    try {
+        return pathExists(unpacked) ? unpacked : candidate;
+    } catch {
+        return candidate;
+    }
+}