@webos-tools/cli 3.0.0

package/lib/shell.js

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const async = require('async'),
+    npmlog = require('npmlog'),
+    sessionLib = require('./session'),
+    errHndl = require('./base/error-handler'),
+    novacom = require('./base/novacom');
+
+(function() {
+    const log = npmlog;
+
+    log.heading = 'logger';
+    log.level = 'warn';
+
+    const shell = {
+        log: log,
+
+        remoteRun: function(options, runCommand, next) {
+            log.info('shell#remoteRun()');
+            async.series([
+                function(next) {
+                    makeSession(options, next);
+                },
+                function(next) {
+                    if (options && options.display) {
+                        sessionLib.getSessionList(options, next);
+                    } else {
+                        next();
+                    }
+                },
+                function(next) {
+                    if (options && options.display && !options.sessionCall) {
+                        setImmediate(next, errHndl.getErrMsg("NOT_SUPPORT_SESSION"), {});
+                    }
+                    next();
+                },
+                function(next) {
+                    if (options.sessionId) {
+                        if (options.session.getDevice().username !== 'root') {
+                            return setImmediate(next, errHndl.getErrMsg("NEED_ROOT_PERMISSION", "connect user session"));
+                        }
+
+                        // -l : make the shell a login shell, -c : command
+                        runCommand = `su ${options.sessionId} -l -c '${runCommand}'`;
+                    } else {
+                        runCommand = "source /etc/profile && " + runCommand;
+                    }
+
+                    log.info("shell#remoteRun()", "cmd :", runCommand);
+                    options.session.run(runCommand, process.stdin, _onData, _onErr, next);
+
+                    function _onData(data) {
+                        const str = (Buffer.isBuffer(data)) ? data.toString() : data;
+                        next(null, str.trim());
+                    }
+
+                    function _onErr(err) {
+                        next(errHndl.getErrMsg(err), null);
+                    }
+
+                }
+            ], function(err, results) {
+                next(err, {msg: results[3]});
+            });
+        },
+
+        shell: function(options, next) {
+            log.info('shell#shell()');
+            const _ssh = function(session, finish) {
+                async.series([
+                    function(next) {
+                        makeSession(options, next);
+                    },
+                    function(next) {
+                        const winOpts = {
+                            // "rows": process.stdout.rows,
+                            // "columns": process.stdout.columns,
+                            "term": 'screen'
+                        };
+                        session.ssh.shell(winOpts, function(err, stream) {
+                            if (err) {
+                                return setImmediate(next, errHndl.getErrMsg(err));
+                            }
+                            open_shell();
+                            function open_shell() {
+                                log.info('shell#shell()#open_shell()');
+                                stream.on('exit', function(code, signal) {
+                                    log.silly('shell#shell()#open_shell()', 'Stream::exit::code:' + code + ', signal: ' + signal);
+                                    session.ssh.end();
+                                    next();
+                                });
+
+                                stream.on('data', function() {
+                                    arrangeWindow(stream);
+                                });
+
+                                process.stdout.on('resize', function() {
+                                    arrangeWindow(stream);
+                                });
+
+                                function  _printGuide() {
+                                    // TO-DO: uncaughtException TypeError: process.stdin.setRawMode is not a function
+                                    process.stdin.setRawMode(true);
+                                }
+
+                                if (options.sessionId) {
+                                    if (options.session.getDevice().username !== 'root') {
+                                        return setImmediate(next, errHndl.getErrMsg("NEED_ROOT_PERMISSION", "connect user session"));
+                                    }
+
+                                    _printGuide();
+
+                                    const cmd = `su ${options.sessionId} -l`;
+                                    session.runWithOption(cmd, {pty: true}, process.stdin, process.stdout, process.stderr, function() {
+                                        session.ssh.end();
+                                        next();
+                                    });
+                                } else {
+                                    _printGuide();
+                                    process.stdin.pipe(stream);
+                                    stream.pipe(process.stdout);
+                                }
+
+                                function arrangeWindow(window) {
+                                    if (winOpts.rows !== process.stdout.rows || winOpts.columns !== process.stdout.columns) {
+                                        window.setWindow(process.stdout.rows, process.stdout.columns);
+                                        winOpts.rows = process.stdout.rows;
+                                        winOpts.columns = process.stdout.columns;
+                                    }
+                                }
+                            }
+                        });
+                    }
+                ], function(err, result) {
+                    let flag_reboot = false;
+                    if (result.indexOf("id") > 0) {
+                        flag_reboot = true;
+                    }
+                    finish(err, flag_reboot);
+                });
+            };
+
+            async.series([
+                function(next) {
+                    makeSession(options, next);
+                },
+                function(next) {
+                    if (options && options.display) {
+                        sessionLib.getSessionList(options, next);
+                    } else {
+                        next();
+                    }
+                },
+                function(next) {
+                    if (options && options.display && !options.sessionCall) {
+                        setImmediate(next, errHndl.getErrMsg("NOT_SUPPORT_SESSION"), {});
+                    }
+                    next();
+                },
+                function(next) {
+                    _ssh(options.session, next);
+                }
+            ], function(err) {
+                if (err) {
+                    next(err);
+                } else {
+                    // Print "Connection to IP closed." message as like ssh prompt
+                    next(err, {msg: "Connection to " + options.session.target.host + " closed."});
+                }
+            });
+        }
+    };
+
+    function makeSession(options, next) {
+        options.nReplies = 1; // -n 1
+        if (!options.session) {
+            log.info("shell#makeSession()", "need to make new session");
+            const printTarget = false;
+            options.session = new novacom.Session(options.device, printTarget, next);
+        } else {
+            log.info("shell#makeSession()", "already exist session");
+            next();
+        }
+    }
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = shell;
+    }
+}());

package/lib/tar-filter-pack.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const collect = require('fstream').collect,
+    inherits = require('inherits'),
+    path = require('path'),
+    tar = require('tar');
+
+module.exports = TarFilterPack;
+inherits(TarFilterPack, tar.Pack);
+
+function TarFilterPack(prop) {
+    const self = this;
+
+    self.permission = prop.permission;
+    if (!(self instanceof TarFilterPack)) {
+        return new TarFilterPack(prop);
+    }
+    TarFilterPack.super.call(self, prop);
+}
+
+TarFilterPack.prototype.add = function(stream) {
+    if (this._global && !this._didGlobal) {
+        this.addGlobal(this._global);
+    }
+
+    if (this._ended) {
+        return this.emit("error", new Error("add after end"));
+    }
+
+    collect(stream);
+
+    if (this.permission[stream.basename]) {
+        stream.props.mode = parseInt(this.permission[stream.basename], 8);
+    }
+
+    // opkg does not support Posix Tar fully
+    if (stream.basename.length !== Buffer.byteLength(stream.basename)) {
+        const errFilePath = path.relative(stream.root.props.path, stream.path),
+            errMsg = "Please use the file name in english letters. \n\t\t (" + errFilePath + ")",
+            em = new(require('events').EventEmitter)();
+
+        em.emit('error', new Error(errMsg));
+    }
+
+    if (stream.props.uid > 0o7777777) {
+        stream.props.uid = 0;
+    }
+
+    if (stream.props.gid > 0o7777777) {
+        stream.props.gid = 0;
+    }
+
+    this._buffer.push(stream);
+    this._process();
+    this._needDrain = this._buffer.length > 0;
+
+    return !this._needDrain;
+};

package/lib/util/copy.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const promise = require('bluebird'),
+    path = require('path'),
+    fs = promise.promisifyAll(require('fs-extra'));
+
+function copyToDirAsync(src, destDir) {
+    return fs.lstatAsync(src).then(function(stats) {
+        if (stats.isFile()) {
+            return fs.copyAsync(src, path.join(destDir, path.basename(src)));
+        } else {
+            return fs.copyAsync(src, destDir);
+        }
+    });
+}
+
+function copyToDirSync(src, destDir) {
+    const stats = fs.lstatSync(src);
+    if (stats.isFile()) {
+        fs.copySync(src, path.join(destDir, path.basename(src)));
+    } else {
+        fs.copySync(src, destDir);
+    }
+}
+
+module.exports.copyToDirAsync = copyToDirAsync;
+module.exports.copyToDirSync = copyToDirSync;

package/lib/util/createFileName.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Return a file name based on Date.
+function createDateFileName(separator, extName) {
+    return __getDate();
+    
+    function __getDate() {
+        if (separator === null || separator === undefined) {
+            separator = "";
+        }
+
+        const curDate = new Date();
+        let dateFormat = __pad(curDate.getFullYear(), 2)
+            +  __pad((curDate.getMonth()+1), 2)
+            + __pad(curDate.getDate(), 2)
+            + separator
+            + __pad(curDate.getHours(), 2)
+            + __pad(curDate.getMinutes(), 2)
+            + __pad(curDate.getSeconds(), 2);
+
+        if (extName) {
+            dateFormat += "." + extName;
+        }
+        return dateFormat;
+    }
+
+    function __pad(number, length) {
+        let str = '' + number;
+        while (str.length < length) {
+            str = '0' + str;
+        }
+        return str;
+    }
+}
+
+module.exports.createDateFileName = createDateFileName;

package/lib/util/eof.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const stream = require('stream'),
+    util = require('util');
+
+(function() {
+    function Eof() {
+        stream.Stream.call(this);
+    }
+
+    util.inherits(Eof, stream.Stream);
+
+    // Readable stream interface
+    Eof.prototype.pause = function() {};
+
+    Eof.prototype.resume = function() {};
+
+    Eof.prototype.destroy = function() {
+        this.emit('end');
+        this.emit('close');
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = Eof;
+    }
+}());

package/lib/util/json.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const promise = require('bluebird'),
+    log = require('npmlog');
+
+const fs = promise.promisifyAll(require('fs'));
+
+function readJsonSync(file) {
+    let result;
+    try {
+        const contents = fs.readFileSync(file, 'utf8');
+        result = JSON.parse(contents.toString().replace(/^\ufeff/g, '')); // Removing BOM
+    } catch (err) {
+        log.warn("json#readJsonSync()", "error:", err);
+        throw err;
+    }
+    return result;
+}
+
+function readJsonAsync(file) {
+    return fs.readFileAsync(file, 'utf8')
+        .then(function(contents) {
+            return JSON.parse(contents.toString().replace(/^\ufeff/g, '')); // Removing BOM
+        })
+        .catch(function(err) {
+            log.warn("json#readJsonAsync()", "error:", err);
+            throw err;
+        });
+}
+
+function convertJsonToList(orgJson, level) {
+    let returnText = "", prefix = "";
+
+    for (let i = 0; i < level; i++) {
+        prefix += "-";
+    }
+
+    if (typeof orgJson === "string") {
+        return returnText += prefix + orgJson + '\n';
+    } else if (Array.isArray(orgJson) && orgJson.length > 0) {
+        for (let index = 0; index < orgJson.length; index++) {
+            returnText += convertJsonToList(orgJson[index], level);
+        }
+    } else {
+        // handle object type
+        for (const key in orgJson) {
+            if (typeof orgJson[key] === "object") {
+                returnText += prefix + key + '\n' +  convertJsonToList(orgJson[key], level + 1);
+            } else {
+                returnText += prefix + key + " : " + orgJson[key] + '\n';
+            }
+        }
+    }
+    return returnText;
+}
+
+module.exports.readJsonSync = readJsonSync;
+module.exports.readJsonAsync = readJsonAsync;
+module.exports.convertJsonToList = convertJsonToList;

package/lib/util/merge.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function merge(srcObj, extendObj) {
+    for (const key in extendObj) {
+        if (Object.prototype.hasOwnProperty.call(extendObj, key)) srcObj[key] = extendObj[key];
+    }
+    return srcObj;
+}
+
+module.exports = merge;

package/lib/util/objclone.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function deepCopy(obj) {
+    if (obj === null || typeof(obj) !== 'object') {
+        return obj;
+    }
+
+    const copy = new obj.constructor();
+    Object.setPrototypeOf(copy, obj);
+
+    for (const attr in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, attr)) {
+        copy[attr] = deepCopy(obj[attr]);
+      }
+    }
+    return copy;
+}
+
+function shallowCopy(obj) {
+    if (obj === null || typeof(obj) !== 'object') {
+        return obj;
+    }
+
+    const copy = new obj.constructor();
+    Object.setPrototypeOf(copy, obj);
+
+    for (const attr in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, attr)) {
+        copy[attr] = obj(obj[attr]);
+      }
+    }
+    return copy;
+}
+
+module.exports.shallowCopy = shallowCopy;
+module.exports.deepCopy = deepCopy;

package/lib/util/spinner.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const ora = require('ora');
+
+(function() {
+    const spinnerHdlr = {},
+        spinner = ora({ 
+        text: "Processing\n",
+        color: "white",
+        spinner: "simpleDots",
+        interval: 200,
+        stream:  process.stdout
+    });
+    
+    spinnerHdlr.start = function(text) {
+        if (text) {
+            spinner.text = text ;
+        }
+        if (!spinner.isSpinning) {
+            spinner.start();
+        }
+    };
+
+    spinnerHdlr.stop = function() {
+        if (spinner.isSpinning) {
+            spinner.stop();
+        }
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = spinnerHdlr;
+    }
+}());

package/npm-shrinkwrap.json

@@ -0,0 +1,85 @@
+{
+  "name": "@webos-tools/cli",
+  "version": "3.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@webos-tools/cli",
+      "version": "3.0.0",
+      "license": "Apache-2.0",
+      "os": [
+        "darwin",
+        "linux",
+        "win32"
+      ],
+      "dependencies": {
+        "ar-async": "0.1.4",
+        "async": "0.2.10",
+        "bluebird": "3.7.2",
+        "body-parser": "1.19.0",
+        "chalk": "1.1.3",
+        "chardet": "0.8.0",
+        "chokidar": "3.5.2",
+        "combined-stream": "1.0.8",
+        "csv-writer": "1.6.0",
+        "decompress": "4.2.1",
+        "easy-table": "1.1.1",
+        "elfy": "1.0.0",
+        "encoding": "0.1.13",
+        "express": "4.17.1",
+        "extract-zip": "1.7.0",
+        "fs-extra": "8.1.0",
+        "fstream": "1.0.12",
+        "graceful-fs": "4.2.4",
+        "inherits": "1.0.2",
+        "inquirer": "7.0.0",
+        "jsonschema": "1.2.6",
+        "mkdirp": "0.5.5",
+        "nopt": "2.1.2",
+        "npmlog": "4.1.2",
+        "ora": "5.4.0",
+        "request": "2.88.2",
+        "rimraf": "3.0.2",
+        "semver": "7.3.2",
+        "shelljs": "0.8.4",
+        "sprintf-js": "1.1.2",
+        "ssdp-js": "1.0.1",
+        "ssh2": "0.8.9",
+        "stream-buffers": "3.0.2",
+        "strip-bom": "1.0.0",
+        "tar": "2.2.2",
+        "temp": "0.9.1",
+        "terser": "4.8.0"
+      },
+      "bin": {
+        "ares": "bin/ares.js",
+        "ares-config": "bin/ares-config.js",
+        "ares-device": "bin/ares-device.js",
+        "ares-device-info": "bin/ares-device-info.js",
+        "ares-generate": "bin/ares-generate.js",
+        "ares-inspect": "bin/ares-inspect.js",
+        "ares-install": "bin/ares-install.js",
+        "ares-launch": "bin/ares-launch.js",
+        "ares-log": "bin/ares-log.js",
+        "ares-novacom": "bin/ares-novacom.js",
+        "ares-package": "bin/ares-package.js",
+        "ares-pull": "bin/ares-pull.js",
+        "ares-push": "bin/ares-push.js",
+        "ares-server": "bin/ares-server.js",
+        "ares-setup-device": "bin/ares-setup-device.js",
+        "ares-shell": "bin/ares-shell.js"
+      },
+      "devDependencies": {
+        "eslint": "6.8.0",
+        "eslint-plugin-import": "2.22.0",
+        "jasmine": "3.8.0",
+        "jasmine-pretty-html-reporter-jasmine3.8": "0.2.5",
+        "jasmine-spec-reporter": "4.2.1"
+      },
+      "engines": {
+        "node": ">=14.15.1"
+      }
+    }
+  }
+}