@kano/kit-app-shell-cli/lib/cli.js

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const Api = require("sywac/api");
const platformUtils = require("@kano/kit-app-shell-core/lib/util/platform");
const process_state_1 = require("@kano/kit-app-shell-core/lib/process-state");
const rc_1 = require("@kano/kit-app-shell-core/lib/rc");
const check_1 = require("@kano/kit-app-shell-core/lib/check");
const types_1 = require("@kano/kit-app-shell-core/lib/types");
const tmp = require("@kano/kit-app-shell-core/lib/tmp");
const prettyBytes = require("pretty-bytes");
const chalk_1 = require("chalk");
class CLI {
    constructor(processArgv) {
        this.processState = process_state_1.processState;
        this.processArgv = processArgv;
    }
    static parseEnv(sywac) {
        return sywac
            .string('--env, -e', {
            desc: 'Target environment',
            defaultValue: 'development',
        });
    }
    static parseAppRoot(sywac) {
        return sywac
            .positional('<app=./>', {
            params: [{
                    required: true,
                    desc: 'Path to the root of the app',
                    coerce: path.resolve,
                }],
        });
    }
    static parseAppBuild(sywac) {
        return sywac
            .positional('<build>', {
            params: [{
                    required: true,
                    desc: 'Path to the built app',
                    coerce: path.resolve,
                }],
        });
    }
    static parseOverrideAppConfig(sywac) {
        return sywac
            .array('-C, --override-app-config <values..>', {
            desc: 'Override app configuration (syntax key.subkey=value)',
            coerce: (strings) => {
                const overrides = {};
                strings.forEach((s) => {
                    const [key, value] = s.split('=');
                    const keyComponents = key.split('.');
                    let currentLevel = overrides;
                    while (keyComponents.length > 1) {
                        const keyComponent = keyComponents.shift();
                        currentLevel[keyComponent] = currentLevel[keyComponent] || {};
                        currentLevel = currentLevel[keyComponent];
                    }
                    let v = value;
                    if (value === 'true') {
                        v = true;
                    }
                    else if (value === 'false') {
                        v = false;
                    }
                    else if (value.match(/^[0-9]+$/)) {
                        v = parseInt(value, 10);
                    }
                    const topLevelKey = keyComponents[0];
                    currentLevel[topLevelKey] = v;
                });
                return overrides;
            },
        });
    }
    static parseRequireAppConfig(sywac) {
        return sywac
            .array('-R, --require-config <path>', {
            desc: 'Require app configuration file',
            coerce: (strings) => {
                return strings.map((s) => path.resolve(s));
            },
        });
    }
    static checkRequireAppConfig(sywac) {
        return sywac
            .check((argv) => {
            if (!argv.R)
                return;
            return argv.R.reduce((p, path) => {
                return p.then(() => {
                    return rc_1.RcLoader.check(path).then((exists) => {
                        if (!exists) {
                            throw new Error(`-R: App config file does not exist: ${path}`);
                        }
                    });
                });
            }, Promise.resolve(true));
        });
    }
    static applyStyles(sywac) {
        return sywac.style({
            group: (s) => chalk_1.default.cyan.bold(s),
            desc: (s) => chalk_1.default.white(s),
            hints: (s) => chalk_1.default.dim(s),
            flagsError: (s) => chalk_1.default.red(s),
        });
    }
    static patchSywacOptions(sywac, forcedOptions) {
        const originalOptions = sywac._addOptionType.bind(sywac);
        sywac._addOptionType = (flags, opts, type) => originalOptions(flags, Object.assign({}, opts, forcedOptions), type);
        return {
            dispose() {
                sywac._addOptionType = originalOptions;
            },
        };
    }
    start() {
        this.startedAt = Date.now();
        return this.firstPass()
            .then((result) => {
            const [, platform] = result.argv._;
            if (platform) {
                return this.secondPass(platform);
            }
            console.log(result.output);
            return this.end(result.code);
        });
    }
    end(code) {
        this.duration = Date.now() - this.startedAt;
        const totalTime = this.duration / 1000;
        const totalMinutes = Math.floor(totalTime / 60);
        const totalSeconds = (totalTime % 60).toFixed(2);
        const msg = `Done in ${totalMinutes}m${totalSeconds.toString().padStart(5, '0')}s.`;
        if (this.reporter) {
            this.reporter.onInfo(msg);
        }
        process.exit(code);
    }
    setTask(task) {
        if (!this.processState) {
            return;
        }
        task.catch((e) => {
            this.processState.setFailure(e);
            return this.end(1);
        });
    }
    mountReporter(argv) {
        if (argv.quiet) {
            return Promise.resolve();
        }
        let p;
        if (process.stdout.isTTY) {
            p = Promise.resolve().then(() => require('./reporters/ora'));
        }
        else {
            p = Promise.resolve().then(() => require('./reporters/console'));
        }
        return p
            .then((ReporterModule) => {
            this.reporter = (new ReporterModule.default());
            this.processState.on('step', ({ message = '' }) => this.reporter.onStep(message));
            this.processState.on('success', ({ message = '' }) => this.reporter.onSuccess(message));
            this.processState.on('failure', ({ message = new Error('') }) => this.reporter.onFailure(message));
            this.processState.on('warning', ({ message = '' }) => this.reporter.onWarning(message));
            this.processState.on('info', ({ message = '' }) => this.reporter.onInfo(message));
        });
    }
    runDoctor() {
        return Promise.resolve().then(() => require('@kano/kit-app-shell-core/lib/checks/index')).then((checkModule) => {
            return check_1.runChecks(checkModule.default);
        });
    }
    displayDoctorResults(results) {
        const DOCTOR_SUCCESS_DEFAULT = 'All good';
        const DOCTOR_WARNING_DEFAULT = 'Warning';
        const DOCTOR_FAILURE_DEFAULT = 'Error';
        let failed = false;
        results.forEach((result) => {
            const message = result.message ? result.message.replace(/\n/g, '\n  ') : null;
            if (result.status === check_1.CheckResultSatus.Success) {
                process_state_1.processState.setSuccess(`${result.title}: ${message || DOCTOR_SUCCESS_DEFAULT}`);
            }
            else if (result.status === check_1.CheckResultSatus.Warning) {
                process_state_1.processState.setWarning(`${result.title}: ${message || DOCTOR_WARNING_DEFAULT}`);
            }
            else {
                process_state_1.processState.setFailure(`${result.title}: ${message || DOCTOR_FAILURE_DEFAULT}`);
                failed = true;
            }
        });
        this.end(failed ? 1 : 0);
    }
    firstPass() {
        const sywac = new Api();
        const commands = ['run', 'build', 'sign', 'configure'];
        sywac.configure({ name: 'kash' });
        commands.forEach((cmd) => {
            sywac.command(`${cmd} <platform> --help`, {
                desc: `Show help for the ${cmd} command`,
                run: (argv) => this.secondPass(argv.platform),
            });
        });
        sywac.command('doctor [platform] --help', {
            desc: 'Show help for the doctor command',
            run: (argv) => {
                if (!argv.platform) {
                    return this.runDoctor();
                }
                return this.secondPass(argv.platform);
            },
        });
        sywac.command('cache', {
            desc: 'Manage the cache files used by kash',
            setup: (setup) => {
                setup.command('status', {
                    desc: 'Displays the status of the cache directory',
                    run: () => {
                        return tmp.status()
                            .then((status) => {
                            let total = 0;
                            Object.keys(status).forEach((key) => {
                                const st = status[key];
                                total += st.size;
                                console.log(`  ${key} size: ${prettyBytes(st.size)}`);
                            });
                            console.log(`  Total size: ${prettyBytes(total)}`);
                            if (total !== 0) {
                                console.log(`Run ${chalk_1.default.cyan('kash cache clear')} to free up some space`);
                            }
                            else {
                                console.log('No cache to clear');
                            }
                        })
                            .then(() => this.end(0));
                    },
                });
                setup.command('clear', {
                    desc: 'Deletes the contents of the cache directory',
                    run: (argv) => {
                        return this.mountReporter(argv)
                            .then(() => tmp.status())
                            .then((status) => {
                            const total = Object.keys(status).reduce((acc, key) => {
                                return acc + status[key].size;
                            }, 0);
                            return tmp.clear()
                                .then(() => process_state_1.processState.setSuccess(`Cleared ${prettyBytes(total)}`));
                        });
                    },
                });
                setup.command('dir', {
                    desc: 'Displays the cache directory location',
                    run: () => {
                        console.log(tmp.getRootPath());
                    },
                });
            },
        });
        sywac.command('open config', {
            desc: 'Open the location of your configuration',
            run: () => {
                return Promise.resolve().then(() => require('./open-config')).then((openConfig) => openConfig.default());
            },
        });
        sywac.help('-h, --help');
        sywac.showHelpByDefault();
        sywac.version();
        CLI.applyStyles(sywac);
        return sywac.parse(this.processArgv);
    }
    secondPass(platformId) {
        const sywac = new Api();
        return platformUtils.loadPlatformKey(platformId, 'cli')
            .then((platformCli) => {
            const platform = {
                cli: platformCli || {},
            };
            sywac.command('build <platform>', {
                desc: 'build the application',
                setup: (s) => {
                    CLI.parseAppRoot(s);
                    CLI.parseEnv(s);
                    CLI.parseOverrideAppConfig(s);
                    CLI.parseRequireAppConfig(s);
                    CLI.checkRequireAppConfig(s);
                    s.array('--resources')
                        .string('--out, -o', {
                        desc: 'Output directory',
                        coerce: path.resolve,
                        required: true,
                    })
                        .number('--build-number, -n', {
                        aliases: ['n', 'build-number', 'buildNumber'],
                        defaultValue: 0,
                    })
                        .boolean('--bundle-only', {
                        aliases: ['bundle-only', 'bundleOnly'],
                        defaultValue: false,
                    })
                        .boolean('--skip-minify-html', {
                        aliases: ['skip-minify-html', 'skipMinifyHtml'],
                        defaultValue: false,
                    })
                        .boolean('--skip-babel', {
                        aliases: ['skip-babel', 'skipBabel'],
                        defaultValue: false,
                    })
                        .boolean('--skip-terser', {
                        aliases: ['skip-terser', 'skipTerser'],
                        defaultValue: false,
                    });
                    const sywacPatch = CLI.patchSywacOptions(s, {
                        group: platform.cli.group || 'Platform: ',
                    });
                    platformUtils.registerOptions(s, platform, types_1.ICommand.Build);
                    sywacPatch.dispose();
                },
                run: (argv) => {
                    this.mountReporter(argv);
                    return Promise.resolve().then(() => require('./command')).then((runCommand) => {
                        const task = runCommand.default('build', platformId, argv);
                        this.setTask(task);
                        return task;
                    });
                },
            });
            sywac.command('run <platform>', {
                desc: 'run the application',
                setup: (s) => {
                    CLI.parseAppRoot(s);
                    CLI.parseEnv(s);
                    CLI.parseOverrideAppConfig(s);
                    CLI.parseRequireAppConfig(s);
                    CLI.checkRequireAppConfig(s);
                    const sywacPatch = CLI.patchSywacOptions(s, {
                        group: platform.cli.group || 'Platform: ',
                    });
                    platformUtils.registerOptions(s, platform, types_1.ICommand.Run);
                    sywacPatch.dispose();
                },
                run: (argv) => {
                    this.mountReporter(argv);
                    return Promise.resolve().then(() => require('./command')).then((runCommand) => {
                        const task = runCommand.default('run', platformId, argv);
                        this.setTask(task);
                        return task;
                    });
                },
            });
            sywac.command('sign <platform>', {
                desc: 'sign an application package',
                setup: (s) => {
                    CLI.parseAppBuild(s);
                    CLI.parseEnv(s);
                    const sywacPatch = CLI.patchSywacOptions(s, {
                        group: platform.cli.group || 'Platform: ',
                    });
                    platformUtils.registerOptions(s, platform, types_1.ICommand.Sign);
                    sywacPatch.dispose();
                },
                run: (argv) => {
                    this.mountReporter(argv);
                    return Promise.resolve().then(() => require('./command')).then((runCommand) => {
                        const task = runCommand.default('sign', platformId, argv);
                        this.setTask(task);
                        return task;
                    });
                },
            });
            sywac.command('configure <platform>', {
                desc: 'configure kash',
                setup: (s) => {
                    const sywacPatch = CLI.patchSywacOptions(s, {
                        group: platform.cli.group || 'Platform: ',
                    });
                    platformUtils.registerOptions(s, platform, types_1.ICommand.Configure);
                    sywacPatch.dispose();
                },
                run: (argv) => {
                    this.mountReporter(argv);
                    return Promise.resolve().then(() => require('./configure')).then((configure) => {
                        const task = configure.default(platformId);
                        this.setTask(task);
                        return task;
                    });
                },
            });
            sywac.command('doctor <platform>', {
                desc: 'run system checks for a platform',
                setup: (s) => {
                    const sywacPatch = CLI.patchSywacOptions(s, {
                        group: platform.cli.group || 'Platform: ',
                    });
                    platformUtils.registerOptions(s, platform, types_1.ICommand.Doctor);
                    sywacPatch.dispose();
                },
                run: (argv) => {
                    this.mountReporter(argv);
                    return Promise.resolve().then(() => require('./doctor')).then((doctor) => {
                        const task = doctor.default(platformId)
                            .then((checks) => check_1.runChecks(checks))
                            .then((results) => this.displayDoctorResults(results));
                        this.setTask(task);
                        return task;
                    });
                },
            });
            sywac.boolean('--quiet, -q', {
                desc: 'Silence all outputs',
                defaultValue: false,
            });
            sywac.boolean('--verbose', {
                desc: 'Displays verbose logs',
                defaultValue: false,
            });
            sywac.help('-h, --help');
            sywac.showHelpByDefault();
            sywac.version();
            sywac.configure({ name: 'kash' });
            const sywacPatcher = CLI.patchSywacOptions(sywac, {
                group: platform.cli.group || 'Platform: ',
            });
            platformUtils.registerCommands(sywac, platform);
            sywacPatcher.dispose();
            CLI.applyStyles(sywac);
            return sywac.parse(this.processArgv)
                .then((result) => {
                if (result.output.length) {
                    console.log(result.output);
                }
                this.end(result.code);
            });
        });
    }
}
const cli = new CLI(process.argv.slice(2));
cli.start();
//# sourceMappingURL=cli.js.map