@webos-tools/cli 3.0.0

package/bin/ares-novacom.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const path = require('path'),
+    log = require('npmlog'),
+    nopt = require('nopt'),
+    async = require('async'),
+    novacom = require('./../lib/base/novacom'),
+    commonTools = require('./../lib/base/common-tools');
+
+const version = commonTools.version,
+    cliControl = commonTools.cliControl,
+    help = commonTools.help,
+    setupDevice = commonTools.setupDevice,
+    appdata = commonTools.appdata,
+    errHndl = commonTools.errMsg;
+
+const processName = path.basename(process.argv[1], '.js');
+
+process.on('uncaughtException', function(err) {
+    log.error('uncaughtException', err.toString());
+    log.verbose('uncaughtException', err.stack);
+    cliControl.end(-1);
+});
+
+const knownOpts = {
+    // generic options
+    "help": Boolean,
+    "hidden-help": Boolean,
+    "level": ['silly', 'verbose', 'info', 'http', 'warn', 'error'],
+    "version": Boolean,
+    // command-specific options
+    "device-list": Boolean,
+    "forward": Boolean,
+    "port": [String, Array],
+    "getkey": Boolean,
+    "passphrase": [String, null],
+    "device": [String, null],
+    "run": [String, null],
+    // no shortHands
+    "put": [String, null],
+    "get": [String, null]
+};
+
+const shortHands = {
+    // generic aliases
+    "h": ["--help"],
+    "hh": ["--hidden-help"],
+    "v": ["--level", "verbose"],
+    "V": ["--version"],
+    // command-specific aliases
+    "D": ["--device-list"],
+    "f": ["--forward"],
+    "p": ["--port"],
+    "k": ["--getkey"],
+    "pass": ["--passphrase"],
+    "d": ["--device"],
+    "r": ["--run"]
+};
+
+const argv = nopt(knownOpts, shortHands, process.argv, 2 /* drop 'node' & 'ares-*.js' */);
+
+log.heading = processName;
+log.level = argv.level || 'warn';
+log.verbose("argv", argv);
+
+const curConfigData = appdata.getConfig(true);
+if (curConfigData.profile !== "tv") {
+    return finish(errHndl.getErrMsg("NOT_SUPPORT_COMMOND", curConfigData.profile));
+}
+
+const options = {
+    name: argv.device
+};
+
+let op;
+if (argv['device-list']) {
+    setupDevice.showDeviceList(finish);
+} else if (argv.getkey) {
+    op = getkey;
+} else if (argv.run) {
+    op = run;
+} else if (argv.forward) {
+    op = forward;
+} else if (argv.version) {
+    version.showVersionAndExit();
+} else {
+    if (argv['hidden-help']) {
+        help.display(processName, appdata.getConfig(true).profile, true);
+    } else {
+        help.display(processName, appdata.getConfig(true).profile, false);
+    }
+    cliControl.end();
+}
+
+if (op) {
+    version.checkNodeVersion(function() {
+        async.series([
+            op.bind(this)
+        ], finish);
+    });
+}
+
+function getkey(next) {
+    const resolver = new novacom.Resolver();
+    async.waterfall([
+        resolver.load.bind(resolver),
+        resolver.getSshPrvKey.bind(resolver, options),
+        function(keyFileName, next) {
+            if (keyFileName) {
+                if (argv.passphrase) {
+                    return next(null, keyFileName, argv.passphrase);
+                }
+                process.stdin.resume();
+                process.stdin.setEncoding('utf8');
+                process.stdout.write('input passphrase [default: webos]:');
+                process.stdin.on('data', function(text) {
+                    let passphrase = text.toString().trim();
+                    if (passphrase === '') {
+                        passphrase = 'webos';
+                    }
+                    log.info('registered passphrase is ', passphrase);
+                    next(null, keyFileName, passphrase);
+                });
+            } else {
+                return next(new Error("Error getting key file from the device"));
+            }
+        },
+        function(keyFileName, passphrase, next) {
+            const target = {};
+            target.name = options.name;
+            target.privateKey = {
+                "openSsh": keyFileName
+            };
+            target.passphrase = passphrase;
+            target.files = 'sftp';
+            target.port = '9922';
+            target.username = 'prisoner';
+            target.password = '@DELETE@';
+            next(null, target);
+        },
+        resolver.modifyDeviceFile.bind(resolver, 'modify')
+    ], function(err) {
+        if (err)
+            return next(err);
+        next(null, {
+            "msg": "Success"
+        });
+    });
+}
+
+function run(next) {
+    if (argv.run === 'true') {
+        finish(errHndl.getErrMsg("EMPTY_VALUE", "DEVICE_COMMAND"));
+    } else {
+        const printTarget = true;
+        options.session = new novacom.Session(options, printTarget, function(err) {
+            if (err) {
+                next(err);
+                return;
+            }
+            options.session.run(argv.run, process.stdin, process.stdout, process.stderr, next);
+        });
+    }
+}
+
+function forward(next) {
+    if (!argv.port || argv.port.toString() === 'true') {
+        finish(errHndl.getErrMsg("EMPTY_VALUE", "DEVICE_PORT:HOST_PORT"));
+    } else {
+        const tasks = [
+            function(next) {
+                const printTarget = true;
+                options.session = new novacom.Session(options, printTarget, next);
+            }
+        ];
+        try {
+            argv.port.forEach(function(portStr) {
+                const portArr = portStr.split(':');
+                const devicePort = parseInt(portArr[0], 10);
+                const localPort = parseInt(portArr[1], 10) || devicePort;
+                tasks.push(function(next) {
+                    options.session.forward(devicePort, localPort, next);
+                });
+                tasks.push(function() {
+                    console.log('forward', 'running...');
+                });
+            });
+        } catch (err) {
+            next(err);
+            return;
+        }
+        async.series(tasks, next);
+    }
+}
+
+function finish(err, value) {
+    if (err) {
+        // handle err from getErrMsg()
+        if (Array.isArray(err) && err.length > 0) {
+            for (const index in err) {
+                log.error(err[index].heading, err[index].message);
+            }
+            log.verbose(err[0].stack);
+        } else {
+            // handle general err (string & object)
+            log.error(err.toString());
+            log.verbose(err.stack);
+        }
+        cliControl.end(-1);
+    } else {
+        log.info('finish():', value);
+        if (value && value.msg) {
+            console.log(value.msg);
+        }
+        cliControl.end();
+    }
+}

package/bin/ares-package.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const async = require('async'),
+    nopt = require('nopt'),
+    log = require('npmlog'),
+    path = require('path'),
+    packageLib = require('../lib/package'),
+    commonTools = require('./../lib/base/common-tools'),
+    errHndl = require('./../lib/base/error-handler');
+
+const cliControl = commonTools.cliControl,
+    version = commonTools.version,
+    help = commonTools.help,
+    appdata = commonTools.appdata;
+
+const processName = path.basename(process.argv[1]).replace(/.js/, '');
+
+process.on('uncaughtException', function(err) {
+    log.error('uncaughtException', err.toString());
+    log.verbose('uncaughtException', err.stack);
+    cliControl.end(-1);
+});
+
+if (process.argv.length === 2) {
+    process.argv.splice(2, 0, '--help');
+}
+
+function PalmPackage() {
+    this.destination = '.';
+    this.options = {};
+    this.appCnt = 0;
+    this.dirCounts = {};
+
+    const knownOpts = {
+        "help": Boolean,
+        "hidden-help": Boolean,
+        "version": Boolean,
+        "level": ['silly', 'verbose', 'info', 'http', 'warn', 'error'],
+        "outdir": path,
+        "check": Boolean,
+        "no-minify": Boolean,
+        "app-exclude": [String, Array],
+        "rom": Boolean,
+        "encrypt": Boolean,
+        "sign": String,
+        "certificate": String,
+        "force": Boolean,
+        "pkgid": String,
+        "pkgversion": String,
+        "pkginfofile": String,
+        "info": String,
+        "info-detail": String
+    };
+
+    const shortHands = {
+        "h": "--help",
+        "hh": "--hidden-help",
+        "V": "--version",
+        "o": "--outdir",
+        "c": "--check",
+        "n": "--no-minify",
+        "e": "--app-exclude",
+        "r": "--rom",
+        "enc": "--encrypt",
+        "s": "--sign",
+        "crt": "--certificate",
+        "f": "--force",
+        "pi": "--pkgid",
+        "pv": "--pkgversion",
+        "pf": "--pkginfofile",
+        "i": "--info",
+        "I": "--info-detail",
+        "v": ["--level", "verbose"]
+    };
+
+    this.argv = nopt(knownOpts, shortHands, process.argv, 2 /* drop 'node' & basename*/);
+
+    this.hiddenhelpString = [
+        "",
+        "EXTRA-OPTION",
+        help.format("-f, --force", "Make .ipk package forcibly with same file structure in APP_DIR"),
+        help.format("","If file/directories in APP_DIR consists of the following structure"),
+        help.format("\t (ex) APP_DIR/"),
+        help.format("\t           +-- usr/"),
+        help.format("\t           +-- usr/bin"),
+        help.format("\t           +-- usr/bin/foo"),
+        help.format("\t           +-- etc/"),
+        help.format("\t           +-- etc/boo.conf"),
+        help.format("","'-f, --force' option will keep this structure in .ipk"),
+        "",
+        help.format("-pn, --pkgname <NAME>", "Set package name"),
+        help.format("-pv, --pkgversion <VERSION>", "Set package version"),
+        "EXAMPLES",
+        "",
+        "# Create a package although directory has no appinfo.json and no services.json",
+        "  make a ipk file which of package name is 'foopkg' and package version is '1.0.1'",
+        "  the following command should generate a foopkg_1.0.1.ipk",
+        processName+" APP_DIR -f -pn foopkg -pv 1.0.1",
+        ""
+    ];
+
+    log.heading = processName;
+    log.level = this.argv.level || 'warn';
+    log.verbose("argv", this.argv);
+
+    /**
+     * For consistent of "$command -v", argv is used.
+     * By nopt, argv is parsed and set key-value in argv object.
+     * If -v or --level option is input with command, it is set key-value in argv.
+     * After it is deleted, If remained key is only one in argv object
+     * (If any other are remained, it's mean another options is input)
+     * and there is no remaining after parsing the input command by nopt
+     * (If any other are remained, it's mean another parameters ares input),
+     * each command of webOS CLI print help message with log message.
+     */
+    if (this.argv.level) {
+        delete this.argv.level;
+        if (this.argv.argv.remain.length === 0 && (Object.keys(this.argv)).length === 1) {
+            this.argv.help = true;
+        }
+    }
+}
+
+PalmPackage.prototype = {
+    unsupportedOptions: {
+        "noclean": 1, // Do not cleanup temporary directories - For debug only
+        "force": 1
+    },
+
+    showUsage: function(hiddenFlag, exitCode) {
+        if (exitCode === undefined) {
+            exitCode = 0;
+        }
+        if (hiddenFlag) {
+            help.display(processName, appdata.getConfig(true).profile, hiddenFlag);
+        } else {
+            help.display(processName, appdata.getConfig(true).profile);
+        }
+        cliControl.end(exitCode);
+    },
+
+    checkAndShowHelp: function() {
+        if (this.argv.help) {
+            this.showUsage(false, 0);
+        } else if (this.argv["hidden-help"]) {
+            this.showUsage(true, 0);
+        }
+    },
+
+    handleOptions: function() {
+        this.options.level = log.level;
+
+        // Pass unsupported options verbatim thru the options Object -- TODO: TBR
+        for (const key in this.argv) {
+            if (this.unsupportedOptions[key]) {
+                this.options[key] = this.argv[key];
+            }
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'minify')) {
+            this.options.minify = this.argv.minify;
+        } else {
+            this.options.minify = true;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'app-exclude')) {
+            this.options.excludefiles = this.argv['app-exclude'];
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'rom')) {
+            this.options.rom = this.argv.rom;
+        } else {
+            this.options.rom = false;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'encrypt')) {
+            this.options.encrypt = this.argv.encrypt;
+        } else {
+            this.options.encrypt = false;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'sign')) {
+            this.options.sign = this.argv.sign;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'certificate')) {
+            this.options.certificate = this.argv.certificate;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'pkgid')) {
+            this.options.pkgid = this.argv.pkgid;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'pkgversion')) {
+            this.options.pkgversion = this.argv.pkgversion;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'pkginfofile')) {
+            this.options.pkginfofile = this.argv.pkginfofile;
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'info-detail')) {
+            this.options.infodetail = this.argv['info-detail'];
+        }
+
+        if (Object.hasOwnProperty.call(this.argv, 'info')) {
+            this.options.info = this.argv.info;
+        }
+    },
+    
+    setOutputDir: function(next) {
+        log.info("setOutputDir()");
+        if (this.argv.outdir) {
+            this.destination = this.argv.outdir;
+        }
+
+        if (this.destination === '.') {
+            this.destination = process.cwd();
+        }
+        next();
+    },
+
+    checkInputDir: function(next) {
+        log.info("checkInputDir()");
+        const packager = new packageLib.Packager();
+        this.dirCounts = packager.checkInputDirectories(this.argv.argv.remain, this.options, next);
+    },
+
+    packageApp: function(next) {
+        log.info("packageApp()");
+        const packager = new packageLib.Packager();
+        if (this.dirCounts.app === 0) { // packaging without app
+            if (Object.prototype.hasOwnProperty.call(this.options, 'pkginfofile') && Object.prototype.hasOwnProperty.call(this.options, 'pkgid')) {
+                this.finish(errHndl.getErrMsg("NOT_USE_WITH_OPTIONS", "pkginfofile, pkgid"));
+                cliControl.end(-1);
+            } else if (Object.prototype.hasOwnProperty.call(this.options, 'pkgid') || Object.prototype.hasOwnProperty.call(this.options, 'pkginfofile')) {
+                if (this.dirCounts.resource > 0) {
+                    packager.resourcePackaging(this.argv.argv.remain, this.destination, this.options, this.outputTxt, next);
+                } else {
+                    packager.servicePackaging(this.argv.argv.remain, this.destination, this.options, this.outputTxt, next);
+                }
+            } else {
+                this.finish(errHndl.getErrMsg("USE_PKGID_PKGINFO"));
+                cliControl.end(-1);
+            }
+        } else { // packaging with app
+            if (Object.prototype.hasOwnProperty.call(this.options, 'pkgversion')) {
+                this.finish(errHndl.getErrMsg("NOT_PACKAGE_WITH_OPTION", "pkgversion"));
+            }
+            packager.generatePackage(this.argv.argv.remain, this.destination, this.options, this.outputTxt, next);
+        }
+    },
+
+    packageProject: function() {
+        async.series([
+            version.checkNodeVersion,
+            this.setOutputDir.bind(this),
+            this.checkInputDir.bind(this),
+            this.packageApp.bind(this)
+        ], this.finish.bind(this));
+    },
+
+    checkApplication: function() {
+        async.series([
+            version.checkNodeVersion,
+            this.checkInputDir.bind(this)
+        ], function(err) {
+            if (err) {
+                return this.finish(err);
+            }
+            return this.finish(null, {msg: "no problems detected"});
+        }.bind(this));
+    },
+
+    showPkgInfo: function() {
+        log.info("showPkgInfo()");
+        const packager = new packageLib.Packager();
+        packager.analyzeIPK(this.options, this.finish);
+    },
+
+    finish: function(err, value) {
+        log.info("finish()");
+        if (err) {
+            // handle err from getErrMsg()
+            if (Array.isArray(err) && err.length > 0) {
+                for (const index in err) {
+                    log.error(err[index].heading, err[index].message);
+                }
+                log.verbose(err[0].stack);
+            } else {
+                // handle general err (string & object)
+                log.error(err.toString());
+                log.verbose(err.stack);
+            }
+            cliControl.end(-1);
+        } else {
+            log.verbose("finish()", "value:", value);
+            if (value && value[value.length-1] && value[value.length-1].msg) {
+                console.log(value[value.length-1].msg);
+            } else if (value && value.msg) {
+                console.log(value.msg);
+            }
+            cliControl.end();
+        }
+    },
+
+    outputTxt: function(value) {
+        log.info("outputTxt()");
+        console.log(value);
+    },
+
+    exec: function() {
+        this.handleOptions();
+        this.checkAndShowHelp();
+
+        if (this.argv.check) {
+            this.checkApplication();
+        } else if (this.argv.version) {
+            version.showVersionAndExit();
+        } else if (this.argv.info || this.argv['info-detail']) {
+            this.showPkgInfo();
+        } else {
+            this.packageProject();
+        }
+    }
+};
+
+// Main
+const cmd = new PalmPackage();
+cmd.exec();