balena-cli/build/app.js

The official balena Command Line Interface

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.setupSentry = void 0;
exports.setMaxListeners = setMaxListeners;
exports.run = run;
const packageJSON = require('../package.json');
const preparser_1 = require("./preparser");
const bootstrap_1 = require("./utils/bootstrap");
const lazy_1 = require("./utils/lazy");
const core_1 = require("@oclif/core");
exports.setupSentry = (0, lazy_1.onceAsync)(async () => {
    const config = await Promise.resolve().then(() => require('./config'));
    const Sentry = await Promise.resolve().then(() => require('@sentry/node'));
    Sentry.init({
        dsn: config.sentryDsn,
        release: packageJSON.version,
    });
    Sentry.getCurrentScope().setExtras({
        node_version: process.version,
        platform: process.platform,
    });
});
async function checkNodeVersion() {
    const validNodeVersions = packageJSON.engines.node;
    if (!(await Promise.resolve().then(() => require('semver'))).satisfies(process.version, validNodeVersions)) {
        const { getNodeEngineVersionWarn } = await Promise.resolve().then(() => require('./utils/messages'));
        console.warn(getNodeEngineVersionWarn(process.version, validNodeVersions));
    }
}
function setupBalenaSdkSharedOptions(settings) {
    const BalenaSdk = require('balena-sdk');
    BalenaSdk.setSharedOptions({
        apiUrl: settings.get('apiUrl'),
        dataDirectory: settings.get('dataDirectory'),
    });
}
function setMaxListeners(maxListeners) {
    require('events').EventEmitter.defaultMaxListeners = maxListeners;
}
async function init() {
    if (process.env.BALENARC_NO_SENTRY) {
        if (process.env.DEBUG) {
            console.error(`WARN: disabling Sentry.io error reporting`);
        }
    }
    else {
        await (0, exports.setupSentry)();
    }
    await checkNodeVersion();
    const settings = new bootstrap_1.CliSettings();
    await (await Promise.resolve().then(() => require('./utils/proxy'))).setupGlobalHttpProxy(settings);
    setupBalenaSdkSharedOptions(settings);
    if (!process.env.BALENARC_OFFLINE_MODE) {
        (await Promise.resolve().then(() => require('./utils/update'))).notify();
    }
}
async function oclifRun(command, options) {
    let deprecationPromise;
    if (!(preparser_1.unsupportedFlag || process.env.BALENARC_UNSUPPORTED)) {
        const { DeprecationChecker } = await Promise.resolve().then(() => require('./deprecation'));
        const deprecationChecker = new DeprecationChecker(packageJSON.version);
        await deprecationChecker.warnAndAbortIfDeprecated();
        deprecationPromise = deprecationChecker.checkForNewReleasesIfNeeded();
    }
    const runPromise = (async function (shouldFlush) {
        var _a, _b;
        let isEEXIT = false;
        try {
            if (options.development) {
                process.env.NODE_ENV = 'development';
                core_1.settings.debug = true;
            }
            await (0, core_1.run)(command, (_a = options.loadOptions) !== null && _a !== void 0 ? _a : options.dir);
        }
        catch (error) {
            if (((_b = error.oclif) === null || _b === void 0 ? void 0 : _b.exit) === 0) {
                isEEXIT = true;
            }
            else {
                if (error instanceof core_1.Errors.CLIError) {
                    const RequiredArgsErrorRegex = /^Missing (\d+) required arg(s?\b)/;
                    if (RequiredArgsErrorRegex.exec(error.message) != null) {
                        error.message = error.message
                            .split('\n')
                            .map((line, i) => {
                            if (i === 0) {
                                return line.replace(RequiredArgsErrorRegex, 'Missing $1 required argument$2');
                            }
                            return line.replace(/^(?<argName>[\w-]+)(?<paddingSpaces>[ ]+)[ ](?<description>\w)/, '$<argName>$<paddingSpaces>: $<description>');
                        })
                            .join('\n');
                        const helpCommand = `balena ${command.map((c, i) => (i === 0 ? c.replace(/:/g, ' ') : c)).join(' ')} --help`;
                        error.message = error.message.replace('\nSee more help with --help', `\nSee more help with \`${helpCommand}\``);
                    }
                }
                throw error;
            }
        }
        if (shouldFlush) {
            const { flush } = await Promise.resolve().then(() => require('@oclif/core'));
            await flush();
        }
        if (isEEXIT) {
            (await Promise.resolve().then(() => require('./fast-boot'))).stop();
        }
    })(!options.noFlush);
    const { trackPromise } = await Promise.resolve().then(() => require('./hooks/prerun'));
    await Promise.all([trackPromise, deprecationPromise, runPromise]);
}
async function run(cliArgs = process.argv, options) {
    try {
        const { setOfflineModeEnvVars, normalizeEnvVars } = await Promise.resolve().then(() => require('./utils/bootstrap'));
        setOfflineModeEnvVars();
        normalizeEnvVars();
        await init();
        (0, preparser_1.checkDeletedCommand)(cliArgs.slice(2));
        const args = await (0, preparser_1.preparseArgs)(cliArgs);
        await oclifRun(args, options);
    }
    catch (err) {
        await (await Promise.resolve().then(() => require('./errors'))).handleError(err);
    }
    finally {
        try {
            (await Promise.resolve().then(() => require('./fast-boot'))).stop();
        }
        catch (e) {
            if (process.env.DEBUG) {
                console.error(`[debug] Stopping fast-boot: ${e}`);
            }
        }
        process.stdin.pause();
    }
}
//# sourceMappingURL=app.js.map