@ciphore/radiocli 0.2.3 → 0.2.5

package/dist/platform/network.js

@@ -0,0 +1,380 @@
+import { resolve4, resolve6 } from 'node:dns/promises';
+import { request as requestHttps } from 'node:https';
+import { parseJsonAsync } from './json-worker.js';
+const maxResolvedResponseBytes = 128 * 1024 * 1024;
+export function networkPolicy(env = process.env) {
+    return { offline: env.RADIOCLI_OFFLINE === '1', lowBandwidth: env.RADIOCLI_LOW_BANDWIDTH === '1' };
+}
+/** A direct connection must never silently bypass an operator-configured proxy. */
+export function allowsDirectDnsFallback(env = process.env, url) {
+    if (url && bypassesProxy(new URL(url), env))
+        return true;
+    return !['http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY', 'all_proxy', 'ALL_PROXY']
+        .some(name => Boolean(env[name]?.trim()));
+}
+/** Configuration preflight only: no network request or proxy credentials. */
+export function networkDiagnostic() {
+    const policy = networkPolicy();
+    if (policy.offline)
+        return { ...policy, status: 'offline', message: 'Public directory and update requests are disabled; cached data and direct stream URLs remain usable.' };
+    try {
+        validateProxyConfiguration(new URL('http://example.invalid'));
+        validateProxyConfiguration(new URL('https://example.invalid'));
+        return { ...policy, status: 'configured', message: 'Network configuration accepted; reachability and TLS are checked per request. External player networking is separate.' };
+    }
+    catch (error) {
+        return { ...policy, status: 'unavailable', message: error instanceof Error ? error.message : 'Network configuration is invalid.' };
+    }
+}
+/** Keep the request deadline active through body consumption, including errors. */
+export async function withExternalResponse(url, { timeoutMs, init = {}, fetchImpl = fetch, maxResponseBytes = maxResolvedResponseBytes }, consume) {
+    if (networkPolicy().offline)
+        throw new Error('RadioCLI is offline (RADIOCLI_OFFLINE=1).');
+    validateProxyConfiguration(new URL(url));
+    init.signal?.throwIfAborted();
+    const controller = new AbortController();
+    const signal = init.signal ? AbortSignal.any([init.signal, controller.signal]) : controller.signal;
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    const timeout = setTimeout(() => controller.abort(new Error(`Network request timed out after ${timeoutMs} ms.`)), timeoutMs);
+    let response;
+    const work = async () => {
+        response = await fetchImpl(url, { ...init, signal });
+        try {
+            // A custom fetch can resolve after the deadline without observing abort.
+            signal.throwIfAborted();
+            response = boundedResponse(response, maxResponseBytes, signal);
+            return await consume(response);
+        }
+        finally {
+            cancelBody(response);
+        }
+    };
+    try {
+        return await Promise.race([work(), aborted]);
+    }
+    finally {
+        clearTimeout(timeout);
+        signal.removeEventListener('abort', onAbort);
+        controller.abort();
+        if (response)
+            cancelBody(response);
+    }
+}
+/** Count actual decoded body bytes, including chunked responses and deceptive
+ * content lengths. Preserve redirects used by playlist/import consumers. */
+function boundedResponse(response, maxBytes, signal) {
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+        throw new Error('Response size limit must be a positive number of bytes.');
+    if (!response.body)
+        return response;
+    const length = Number(response.headers.get('content-length'));
+    if (Number.isFinite(length) && length > maxBytes)
+        throw responseSizeError(maxBytes);
+    const reader = response.body.getReader();
+    let bytes = 0;
+    let ended = false;
+    let controller;
+    const cleanup = () => signal.removeEventListener('abort', aborted);
+    const aborted = () => {
+        if (ended)
+            return;
+        ended = true;
+        cleanup();
+        controller.error(signal.reason);
+        void reader.cancel(signal.reason).catch(() => undefined);
+    };
+    const body = new ReadableStream({
+        start(value) { controller = value; signal.addEventListener('abort', aborted, { once: true }); },
+        async pull(value) {
+            try {
+                const chunk = await reader.read();
+                if (ended)
+                    return;
+                if (chunk.done) {
+                    ended = true;
+                    cleanup();
+                    value.close();
+                    return;
+                }
+                bytes += chunk.value.byteLength;
+                if (bytes > maxBytes) {
+                    ended = true;
+                    cleanup();
+                    const error = responseSizeError(maxBytes);
+                    value.error(error);
+                    void reader.cancel(error).catch(() => undefined);
+                    return;
+                }
+                value.enqueue(chunk.value);
+            }
+            catch (error) {
+                if (!ended) {
+                    ended = true;
+                    cleanup();
+                    value.error(error);
+                }
+            }
+        },
+        cancel(reason) { ended = true; cleanup(); void reader.cancel(reason).catch(() => undefined); }
+    });
+    const bounded = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+    for (const key of ['url', 'redirected', 'type'])
+        Object.defineProperty(bounded, key, { value: response[key] });
+    Object.defineProperty(bounded, 'json', { value: async () => parseJsonAsync(await bounded.text(), signal) });
+    return bounded;
+}
+function responseSizeError(maxBytes) {
+    return new Error(`HTTP response exceeded the ${maxBytes} byte safety limit.`);
+}
+/**
+ * HTTPS fetch fallback for systems where libc getaddrinfo() reports EAI_AGAIN
+ * but Node's DNS-protocol resolver can still reach the configured nameserver.
+ * The original hostname remains the HTTP Host and TLS SNI identity, so normal
+ * certificate-chain and hostname verification remain enabled.
+ */
+export async function fetchHttpsWithSystemResolver(input, init = {}, runtime = {}) {
+    const url = new URL(input);
+    if (url.protocol !== 'https:')
+        throw new Error('The DNS fallback only supports HTTPS requests.');
+    if (url.username || url.password)
+        throw new Error('The DNS fallback does not accept URL credentials.');
+    const method = (init.method ?? 'GET').toUpperCase();
+    if (method !== 'GET' && method !== 'HEAD')
+        throw new Error('The DNS fallback only supports GET and HEAD requests.');
+    if (init.body)
+        throw new Error('The DNS fallback does not accept a request body.');
+    init.signal?.throwIfAborted();
+    const addresses = await resolveHttpsAddresses(url.hostname, init.signal, runtime);
+    let lastError = null;
+    for (const address of addresses) {
+        try {
+            return await requestResolvedHttps(url, address, init, runtime, method);
+        }
+        catch (error) {
+            if (init.signal?.aborted)
+                throw init.signal.reason;
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    throw lastError ?? new Error(`DNS did not return an address for ${url.hostname}.`);
+}
+async function resolveHttpsAddresses(hostname, signal, runtime) {
+    let lastErrors = [];
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const results = await raceAbort(Promise.allSettled([
+            (runtime.resolve4 ?? resolve4)(hostname),
+            (runtime.resolve6 ?? resolve6)(hostname)
+        ]), signal);
+        const addresses = [
+            ...(results[0].status === 'fulfilled' ? results[0].value.map(address => ({ address, family: 4 })) : []),
+            ...(results[1].status === 'fulfilled' ? results[1].value.map(address => ({ address, family: 6 })) : [])
+        ];
+        if (addresses.length > 0)
+            return dedupeAddresses(addresses);
+        lastErrors = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+        if (attempt === 1 || !lastErrors.some(isTemporaryDnsError))
+            break;
+        await abortableDelay(100, signal);
+    }
+    const lastError = lastErrors.find(value => value instanceof Error);
+    throw lastError instanceof Error ? lastError : new Error(`DNS did not return an address for ${hostname}.`);
+}
+function requestResolvedHttps(url, address, init, runtime, method) {
+    return new Promise((resolve, reject) => {
+        const headers = new Headers(init.headers);
+        if (!headers.has('host'))
+            headers.set('host', url.host);
+        if (!headers.has('accept-encoding'))
+            headers.set('accept-encoding', 'identity');
+        const request = (runtime.request ?? requestHttps)({
+            hostname: address.address,
+            family: address.family,
+            port: url.port ? Number(url.port) : 443,
+            path: `${url.pathname}${url.search}`,
+            method,
+            headers: Object.fromEntries(headers.entries()),
+            servername: url.hostname,
+            signal: init.signal ?? undefined,
+            ca: runtime.ca,
+            agent: false
+        }, response => {
+            const chunks = [];
+            let bytes = 0;
+            response.on('data', (chunk) => {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                bytes += buffer.length;
+                if (bytes > maxResolvedResponseBytes) {
+                    response.destroy(new Error('HTTPS response exceeded the 128 MiB safety limit.'));
+                    return;
+                }
+                chunks.push(buffer);
+            });
+            response.once('error', reject);
+            response.once('aborted', () => reject(new Error('HTTPS response ended before completion.')));
+            response.once('end', () => {
+                const responseHeaders = new Headers();
+                for (const [name, value] of Object.entries(response.headers)) {
+                    if (Array.isArray(value)) {
+                        for (const item of value)
+                            responseHeaders.append(name, item);
+                    }
+                    else if (value !== undefined) {
+                        responseHeaders.set(name, value);
+                    }
+                }
+                const status = response.statusCode ?? 500;
+                const body = method === 'HEAD' || status === 204 || status === 205 || status === 304
+                    ? null
+                    : Buffer.concat(chunks);
+                resolve(new Response(body, {
+                    status,
+                    statusText: response.statusMessage,
+                    headers: responseHeaders
+                }));
+            });
+        });
+        request.once('error', reject);
+        request.end();
+    });
+}
+function dedupeAddresses(addresses) {
+    const seen = new Set();
+    return addresses.filter(({ address, family }) => {
+        const key = `${family}:${address}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function isTemporaryDnsError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'EAI_AGAIN';
+}
+function raceAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+function abortableDelay(ms, signal) {
+    if (!signal)
+        return new Promise(resolve => setTimeout(resolve, ms));
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(done, ms);
+        const onAbort = () => done(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        function done(error) {
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', onAbort);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        }
+    });
+}
+function cancelBody(response) {
+    // Cancellation is best-effort and must not extend the request deadline. A
+    // locked native body is interrupted by the request's AbortController instead.
+    if (response.body && !response.body.locked)
+        void response.body.cancel().catch(() => { });
+}
+function validateProxyConfiguration(url) {
+    if (bypassesProxy(url, process.env))
+        return;
+    const http = proxyVariable('http_proxy', 'HTTP_PROXY');
+    const https = proxyVariable('https_proxy', 'HTTPS_PROXY');
+    for (const proxy of [http, https]) {
+        if (!proxy.value)
+            continue;
+        let parsed;
+        try {
+            if (/[\r\n]/.test(proxy.value))
+                throw new Error();
+            parsed = new URL(proxy.value);
+            decodeURIComponent(parsed.username);
+            decodeURIComponent(parsed.password);
+        }
+        catch {
+            // URL parse errors can contain credentials. Do not attach the raw cause.
+            throw new Error(`${proxy.name} contains an invalid proxy URL.`);
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw new Error(`${proxy.name} uses an unsupported proxy protocol. This Node HTTP client supports HTTP(S) proxies; SOCKS proxies are unavailable.`);
+        }
+    }
+    // Native fetch falls back to HTTP_PROXY for HTTPS when HTTPS_PROXY is unset.
+    const selected = url.protocol === 'https:' && https.value ? https : http;
+    if (!selected.value) {
+        const all = proxyVariable('all_proxy', 'ALL_PROXY');
+        if (all.value)
+            throw new Error(`${all.name} is not supported by this Node HTTP client. Configure HTTP_PROXY or HTTPS_PROXY with an HTTP(S) proxy; SOCKS proxies are unavailable.`);
+        return;
+    }
+    const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+    if (major < 24 && !(major === 22 && minor >= 21)) {
+        throw new Error('Native HTTP(S) proxy support requires Node 22.21+ or Node 24+.');
+    }
+    let enabled = process.env.NODE_USE_ENV_PROXY === '1';
+    const environmentFlags = (process.env.NODE_OPTIONS ?? '').match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+    for (const raw of [...environmentFlags, ...process.execArgv]) {
+        const flag = raw.replace(/^["']|["']$/g, '');
+        if (flag === '--use-env-proxy')
+            enabled = true;
+        if (flag === '--no-use-env-proxy')
+            enabled = false;
+    }
+    if (!enabled) {
+        throw new Error(`${selected.name} is configured. Start RadioCLI with NODE_USE_ENV_PROXY=1 to enable the native HTTP(S) proxy.`);
+    }
+    // Node configures its dispatcher at startup. Do not mutate proxy environment
+    // variables or install a global dispatcher here; local IPC has a direct agent.
+}
+function bypassesProxy(url, env) {
+    const value = env.no_proxy !== undefined ? env.no_proxy : env.NO_PROXY;
+    if (!value?.trim())
+        return false;
+    const hostname = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    const port = url.port || (url.protocol === 'https:' ? '443' : url.protocol === 'http:' ? '80' : '');
+    return value.split(',').some(raw => {
+        let entry = raw.trim().toLowerCase();
+        if (!entry)
+            return false;
+        if (entry === '*')
+            return true;
+        let entryPort = '';
+        if (entry.startsWith('[')) {
+            const end = entry.indexOf(']');
+            if (end < 0)
+                return false;
+            entryPort = entry.slice(end + 1).replace(/^:/, '');
+            entry = entry.slice(1, end);
+        }
+        else {
+            const colon = entry.lastIndexOf(':');
+            if (colon > -1 && /^\d+$/.test(entry.slice(colon + 1))) {
+                entryPort = entry.slice(colon + 1);
+                entry = entry.slice(0, colon);
+            }
+        }
+        if (entryPort && entryPort !== port)
+            return false;
+        const suffix = entry.replace(/^\*\./, '.');
+        return suffix.startsWith('.')
+            ? hostname === suffix.slice(1) || hostname.endsWith(suffix)
+            : hostname === suffix;
+    });
+}
+function proxyVariable(lower, upper) {
+    const name = process.env[lower] !== undefined ? lower : upper;
+    return { name, value: process.env[name] };
+}

package/dist/platform/omarchy.js

@@ -0,0 +1,147 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, constants, fstatSync, openSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { posix } from 'node:path';
+import { resolveCommandDetails } from './executables.js';
+import { identifyPlatform } from './runtime.js';
+const packagedRoot = '/usr/share/omarchy';
+const maxProbeBytes = 4096;
+const probeTimeoutMs = 500;
+const installationCache = new Map();
+const probeIdentities = new WeakMap();
+let nextProbeIdentity = 0;
+const absent = { kind: 'none', version: null, major: null, source: null, root: null, packageName: null };
+/** Omarchy is desktop evidence, not a replacement for the Linux platform ID. */
+export function identifyOmarchy(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const remote = Boolean(env.SSH_CONNECTION?.trim() || env.SSH_CLIENT?.trim() || env.SSH_TTY?.trim() || /^(?:1|true|yes)$/i.test(env.XDG_SESSION_REMOTE ?? ''));
+    const headless = /^(?:tty|unspecified)$/i.test(env.XDG_SESSION_TYPE ?? '');
+    const type = !headless && env.WAYLAND_DISPLAY?.trim() ? 'wayland' : !headless && env.DISPLAY?.trim() ? 'x11' : 'headless';
+    const session = { type, remote, localDesktop: !remote && type !== 'headless' };
+    const unavailable = { available: false, command: null, missing: [] };
+    const injected = Boolean(options.readFile || options.isDirectory || options.run);
+    // Cross-platform callers/tests must not inspect the execution host's files.
+    if (identifyPlatform({ platform, env }).id !== 'linux' || platform !== process.platform && !injected) {
+        return { ...absent, session, terminal: unavailable };
+    }
+    const resolve = options.resolve ?? (command => resolveCommandDetails(command, { platform, env }).path ?? undefined);
+    const home = options.home ?? env.HOME ?? homedir();
+    const readFile = options.readFile ?? readSmallFile;
+    const isDirectory = options.isDirectory ?? directoryExists;
+    const run = options.run ?? probeCommand;
+    const now = (options.now ?? Date.now)();
+    const key = [home, env.OMARCHY_PATH, env.PATH, options.resolve, readFile, isDirectory, run].map(value => typeof value === 'function' ? probeIdentity(value) : value).join('\0');
+    // Cache installation probes, but revalidate launcher executables/session on
+    // every request so saved alarm selectors do not retain stale capabilities.
+    const cached = installationCache.get(key);
+    const installation = cached && now >= cached.checkedAt && now - cached.checkedAt < 5000 ? cached.installation
+        : detectInstallation({ env, home, resolve, readFile, isDirectory, run });
+    if (installation !== cached?.installation) {
+        if (installationCache.size >= 32)
+            installationCache.clear();
+        installationCache.set(key, { checkedAt: now, installation });
+    }
+    if (installation.kind !== 'quattro')
+        return { ...installation, session, terminal: unavailable };
+    const command = resolveAbsolute(resolve, posix.join(packagedRoot, 'bin', 'omarchy-launch-tui')) ?? resolveAbsolute(resolve, 'omarchy-launch-tui');
+    // The upstream script invokes these by name. Fallback executable discovery
+    // outside PATH cannot establish that its unchanged environment can run them.
+    const missing = ['setsid', 'uwsm-app', 'xdg-terminal-exec'].filter(name => !reachableOnPath(resolve, name, env.PATH));
+    if (!command)
+        missing.unshift('omarchy-launch-tui');
+    if (!session.localDesktop || type !== 'wayland')
+        missing.push('local-wayland-session');
+    if (!env.DBUS_SESSION_BUS_ADDRESS?.trim())
+        missing.push('session-bus');
+    return { ...installation, session, terminal: { available: missing.length === 0, command, missing } };
+}
+function detectInstallation(options) {
+    const { env, home, resolve, readFile, isDirectory, run } = options;
+    const configuredRoot = safeAbsolute(env.OMARCHY_PATH);
+    // A custom checkout is deliberately kept separate from the packaged release.
+    if (configuredRoot && configuredRoot !== packagedRoot && isDirectory(configuredRoot)) {
+        const metadata = versionFrom(readFile(posix.join(configuredRoot, 'version')));
+        const helper = resolveAbsolute(resolve, posix.join(configuredRoot, 'bin', 'omarchy-version'));
+        if (metadata || helper)
+            return { kind: metadata?.major === 3 ? 'legacy' : 'development', version: metadata?.version ?? null, major: metadata?.major ?? null, source: metadata ? 'legacy-metadata' : 'helper', root: configuredRoot, packageName: null };
+    }
+    if (isDirectory(packagedRoot)) {
+        const pacman = resolveAbsolute(resolve, 'pacman');
+        if (pacman) {
+            for (const name of ['omarchy-dev', 'omarchy']) {
+                const output = boundedOutput(run(pacman, ['-Q', name], { env, timeout: probeTimeoutMs, maxBuffer: maxProbeBytes }));
+                const match = output && new RegExp(`^${name} ([^\\s]+)$`).exec(output);
+                if (!match)
+                    continue;
+                const version = versionFrom(match[1]);
+                return { kind: name === 'omarchy-dev' ? 'development' : releaseKind(version?.major), version: version?.version ?? match[1], major: version?.major ?? null, source: 'package', root: packagedRoot, packageName: name };
+            }
+        }
+        const helper = resolveAbsolute(resolve, posix.join(packagedRoot, 'bin', 'omarchy-version'));
+        const output = helper ? boundedOutput(run(helper, [], { env: { ...env, OMARCHY_PATH: packagedRoot }, timeout: probeTimeoutMs, maxBuffer: maxProbeBytes })) : null;
+        const version = versionFrom(output);
+        // The packaged helper strips the package name from both omarchy-dev and
+        // omarchy. Its numeric output preserves version diagnostics but cannot
+        // establish the stable channel needed for automatic Quattro integration.
+        return { kind: output?.startsWith('dev') ? 'development' : 'unknown', version: version?.version ?? output, major: version?.major ?? null, source: output ? 'helper' : null, root: packagedRoot, packageName: null };
+    }
+    const legacyRoot = safeAbsolute(posix.join(home, '.local', 'share', 'omarchy'));
+    const metadata = legacyRoot && isDirectory(legacyRoot) ? versionFrom(readFile(posix.join(legacyRoot, 'version'))) : null;
+    if (metadata && legacyRoot)
+        return { kind: metadata.major === 3 ? 'legacy' : 'development', ...metadata, source: 'legacy-metadata', root: legacyRoot, packageName: null };
+    return { ...absent };
+}
+function releaseKind(major) { return major === 4 ? 'quattro' : major !== undefined && major < 4 ? 'legacy' : 'unknown'; }
+function probeIdentity(probe) { const current = probeIdentities.get(probe); if (current !== undefined)
+    return current; const next = ++nextProbeIdentity; probeIdentities.set(probe, next); return next; }
+function boundedOutput(value) { const trimmed = value?.trim(); return trimmed && Buffer.byteLength(value, 'utf8') <= maxProbeBytes && !/[\0\r\n]/.test(trimmed) ? trimmed : null; }
+function versionFrom(value) {
+    const version = boundedOutput(value);
+    const match = version && /^(?:\d+:)?(\d+)\.\d+\.\d+(?:-\d+(?:\.\d+)?)?$/.exec(version);
+    return match ? { version: version, major: Number(match[1]) } : null;
+}
+function safeAbsolute(value) { return value && posix.isAbsolute(value) && !/[\0\r\n]/.test(value) ? posix.normalize(value) : null; }
+function resolveAbsolute(resolve, command) { return safeAbsolute(resolve(command)); }
+function reachableOnPath(resolve, command, path) {
+    if (path === undefined || /[\0\r\n]/.test(path))
+        return false;
+    return path.split(':').some(directory => {
+        const candidate = posix.resolve(directory || '.', command);
+        return resolveAbsolute(resolve, candidate) === candidate;
+    });
+}
+function directoryExists(path) { try {
+    return statSync(path).isDirectory();
+}
+catch {
+    return false;
+} }
+function readSmallFile(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        const stat = fstatSync(descriptor);
+        if (!stat.isFile() || stat.size > maxProbeBytes)
+            return null;
+        const buffer = Buffer.alloc(maxProbeBytes + 1);
+        const count = readSync(descriptor, buffer, 0, buffer.length, 0);
+        return count > maxProbeBytes ? null : buffer.toString('utf8', 0, count);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function probeCommand(command, args, options) {
+    try {
+        const result = spawnSync(command, args, { ...options, killSignal: 'SIGKILL', encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return result.error || result.status !== 0 ? null : boundedOutput(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}