@webos-tools/cli 3.0.0

package/lib/base/file-watcher.js

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const chokidar = require('chokidar');
+const path = require('path');
+const fs = require('fs');
+const npmlog = require('npmlog');
+const luna = require('./luna');
+const errHndl = require('./error-handler');
+
+(function() {
+    const log = npmlog;
+    log.heading = 'fileWatcher';
+    log.level = 'warn';
+    let isCalled = false;
+    const ignoreListFile = '.reloadignore';
+
+    const fileWatcher = {
+        /**
+         * @property {Object} log an npm log instance
+         */
+        log: log,
+
+        /**
+         * Start to watch the given path in local PC
+         * and relaunch the hosted app when any event is triggered
+         * @param {Object} options
+         * @property options {String} device the device to connect to
+         * @property options {String} directory path to watch
+         */
+        watch: function(options, params) {
+            log.verbose('file-watcher#watch()');
+            const watchDir = options.hostedurl;
+            const watcher = this._startWatcher(watchDir);
+
+            watcher.on('all', (event, filePath) => {
+                log.verbose('file-watcher#watch():', event, filePath);
+                if (path.basename(filePath) === ignoreListFile) {
+                    // Close and restart watcher with modified watch option
+                    watcher.close().then(() => {
+                        log.verbose('file-watcher#watch():', 'ignoreListFile changed');
+                        this.watch(options);
+                    });
+                } else {
+                    this._launch(options, params, function(err) {
+                        if (err) {
+                            console.log('Failed to relaunch Ares Hosted App');
+                            log.error(err.toString());
+                            log.verbose(err.stack);
+                        }
+                        return;
+                    });
+                }
+            });
+
+            watcher.on('error', (err) => {
+                log.error(`Watcher error: ${err}`);
+            });
+
+            process.on("SIGINT", function() {
+                watcher.close().then(() => {
+                   log.verbose('file-watcher#watch():', 'SIGINT is detected, watcher close', watchDir);
+                });
+            });
+        },
+
+        _startWatcher: function(watchDir) {
+            const ignoredFiles = this._readIgnoreList(watchDir);
+            log.verbose('file-watcher#_startWatcher():', 'ignored', ignoredFiles);
+            const watchOptions = {
+                ignored: ignoredFiles,
+                ignoreInitial: true
+            };
+            return chokidar.watch(watchDir, watchOptions);
+        },
+
+        _readIgnoreList: function(watchDir) {
+            const ignoreListFilePath = path.join(watchDir, ignoreListFile);
+            log.verbose('file-watcher#_readIgnoreList():', ignoreListFilePath);
+            if (fs.existsSync(ignoreListFilePath)) {
+                try {
+                    // read and parse ignoreListFile into an array
+                    const ignoreListStr = fs.readFileSync(ignoreListFilePath, 'utf-8');
+                    log.silly('file-watcher#_readIgnoreList():', 'fs.readFileSync:', ignoreListStr);
+                    const ignoreListArr = ignoreListStr.split(/\r?\n/);
+                    for (let i = 0; i < ignoreListArr.length; i++) {
+                        // check if empty
+                        if (ignoreListArr[i] === '') {
+                            ignoreListArr.splice(i, 1);
+                            i--;
+                            continue;
+                        }
+                        // check if path is absolute, otherwise change to absolute
+                        if (ignoreListArr[i] && !path.isAbsolute(ignoreListArr[i])) {
+                            if (ignoreListArr[i].indexOf('**') === 0) {
+                                continue;
+                            }
+                            ignoreListArr[i] = path.join(watchDir, ignoreListArr[i]);
+                        }
+                    }
+                    return ignoreListArr;
+                } catch (err) {
+                    log.error(err);
+                    return [];
+                }
+            } else {
+                return [];
+            }
+        },
+
+        _launch: function(options, params, next) {
+            if (isCalled) {
+                return;
+            } else {
+                isCalled = true;
+            }
+            const target = options.session.getDevice();
+            const addr = target.lunaAddr.launch;
+            const returnValue = addr.returnValue.split('.');
+            const param = {
+                // luna param
+                id: options.appId,
+                subscribe: false,
+                params: params
+            };
+            luna.send(options, addr, param, function(lineObj, next) {
+                log.silly('file-watcher#_launch():', 'Relaunch lineObj:', lineObj);
+                let resultValue = lineObj;
+
+                for (let index = 1; index < returnValue.length; index++) {
+                    resultValue = resultValue[returnValue[index]];
+                }
+                if (resultValue) {
+                    // success: stop
+                    log.verbose('file-watcher#_launch():', 'Relaunch success');
+                    isCalled = false;
+                    next(null);
+                } else {
+                    // failure: stop
+                    log.verbose('file-watcher#_launch():', 'Relaunch failure');
+                    isCalled = false;
+                    next(errHndl.getErrMsg("INVALID_OBJECT"));
+                }
+            }, next);
+        },
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = fileWatcher;
+    }
+
+}());

package/lib/base/help-format.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const fs = require('fs'),
+    path = require('path'),
+    sprintf = require('sprintf-js').sprintf;
+
+(function() {
+    const helpFormat = {};
+
+    helpFormat.display = function(processName, profile, hiddenFlag) {
+        const helpFile = path.join(__dirname, '../../files/help', processName + '.help');
+        let helpString = [];
+        this.profile = profile;
+
+        try {
+            const data = JSON.parse(fs.readFileSync(helpFile, 'utf8'));
+            data.display.forEach(function(prop) {
+                helpString.push("");
+                if (!data.notitle || data.notitle.indexOf(prop) === -1) {
+                    helpString.push(prop.toUpperCase());
+                }
+
+                if (data.notab && data.notab.indexOf(prop) !== -1) {
+                    helpString = helpString.concat(helpFormat.stringFormat(data[prop], false, hiddenFlag));
+                } else {
+                    helpString = helpString.concat(helpFormat.stringFormat(data[prop], true, hiddenFlag));
+                }
+            });
+            helpFormat.print(helpString);
+        } catch (err) {
+            console.log(err);
+            throw err;
+        }
+    };
+
+    helpFormat.string = function(data, tab) {
+        let helpString = "";
+        if (data === undefined) return [];
+
+        data = data.split("@TAB@");
+        for (const index in data) {
+            if (index !== 0 || tab) {
+                helpString += sprintf("\t%-32s", data[index]);
+            } else {
+                helpString += sprintf(data[index]);
+            }
+        }
+        return [helpString];
+    };
+
+    helpFormat.stringArray = function(data, tab) {
+        let helpString = [];
+        for (const index in data) {
+            helpString = helpString.concat(helpFormat.stringFormat(data[index], tab));
+        }
+        return helpString;
+    };
+
+    helpFormat.optionObject = function(data, tab) {
+        let helpString = [],
+            optionList = [].concat(data.default||[]).concat(data.default-process||[]);
+        optionList = optionList.concat(data[this.profile]||[]).concat(data[process.platform]||[]);
+        for (const index in optionList) {
+            helpString = helpString.concat(helpFormat.stringFormat(data[optionList[index]], tab));
+        }
+        return helpString;
+    };
+
+    helpFormat.stringObject = function(data, tab) {
+        const defaultData = [].concat(data.default||[]).concat(data.default-process||[]),
+            currentData = [].concat(data[this.profile]||[]).concat(data[process.platform]||[]);
+        let helpString = [];
+        helpString = helpString.concat(helpFormat.stringFormat(defaultData.concat(currentData), tab));
+        return helpString;
+    };
+
+    helpFormat.hiddenObject = function(data, tab, hiddenFlag) {
+        return (hiddenFlag) ? helpFormat.stringObject(data, tab) : [];
+    };
+
+    helpFormat.stringFormat = function(data, tab, hiddenFlag) {
+        let helpString = [];
+        if (Array.isArray(data)) {
+            helpString = helpString.concat(helpFormat.stringArray(data, tab));
+        } else if (typeof data === 'object') {
+            if (data.cmdOpt && data.cmdOpt === 'option') {
+                helpString = helpString.concat(helpFormat.optionObject(data, tab));
+            }
+            else if (data.cmdOpt && data.cmdOpt === 'hidden') {
+                helpString = helpString.concat(helpFormat.hiddenObject(data, tab, hiddenFlag));
+            } else {
+                helpString = helpString.concat(helpFormat.stringObject(data, tab));
+            }
+        } else {
+            helpString = helpString.concat(helpFormat.string(data, tab));
+        }
+        return helpString;
+    };
+
+    helpFormat.format =  function(msg) {
+        let helpString = "",
+            dependOnPlatform = false,
+            accept = false;
+        msg = [].concat(msg);
+
+        msg.forEach(function(platform) {
+            if (["win32", "linux", "darwin"].indexOf(platform) !== -1) {
+                dependOnPlatform = true;
+                if (platform === process.platform) {
+                    accept = true;
+                }
+            }
+        });
+
+        let idx = 0;
+        if (dependOnPlatform === true) {
+            if (accept === true) {
+                idx = 1;
+            } else {
+                return null;
+            }
+        }
+
+        for (; idx < arguments.length; idx++) {
+            helpString = helpString.concat(sprintf('\t%-30s', arguments[idx]));
+        }
+        return helpString;
+    };
+
+    helpFormat.print = function(arrayStrHelp) {
+        arrayStrHelp = [].concat(arrayStrHelp);
+
+        arrayStrHelp.forEach(function(line) {
+            if (typeof line === 'string') {
+                console.log(line);
+            }
+        });
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = helpFormat;
+    }
+}());

package/lib/base/luna.js

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const npmlog = require('npmlog'),
+    errHndl = require('./error-handler'),
+    Eof = require('../util/eof');
+
+(function() {
+    const log = npmlog;
+    log.heading = 'luna';
+    log.level = 'http';
+
+    const luna = {
+        /**
+         * send a command on a luna bus
+         * @property options {novacom.Session} session
+         * @param {Object} options
+         * @param {Object} addr
+         * @property addr {String} service luna service name
+         * @property addr {String} [folder] containing folder of the requested method
+         * @property addr {String} method the luna method to invoke
+         * @param {Object} param the unique luna parameter
+         * @param {Function} onResponse the callback invoked at each JSON object received from luna-send
+         * @property onResponse {Object} obj the JSON object received
+         * @property onResponse {Function} next a common-js callback
+         * @param next {Function} next a common-js callback
+         */
+        send: function(options, addr, param, onResponse, next) {
+            const session = options && options.session;
+            // 'is' is used to transmit an EOF to
+            // terminate the remote luna-send.  this is
+            // the only way to terminate an interactive
+            // request 'luna-send -i'...
+            const is = new Eof(),
+                url = ['luna:/', addr.service, addr.folder, addr.method].join('/');
+            let result, mode, sessionCall = "";
+
+            is.pause();
+            if (options && options.nReplies) {
+                mode = "-n " + options.nReplies + " ";
+            } else {
+                mode = "-i ";
+            }
+
+            if (options && options.sessionCall && options.sessionId) {
+                sessionCall = "-c " + options.sessionId + " ";
+            }
+
+            log.verbose("luna#send()", "calling:", mode + sessionCall + url + " '" + JSON.stringify(param) + "'");
+            session.run(session.getDevice().lunaSend + " " + mode + sessionCall + url + " '" + JSON.stringify(param) + "'", is /* stdin*/, _onData, process.stderr, function(err) {
+            if (err) {
+                next(err);
+            }
+                // success when the output of the
+                // command is correctly interpreted,
+                // not simply when the command exit
+                // with a success exit code.
+            });
+
+            let jsonLine = "";
+
+            // Break string into lines (JSON.parse needs a
+            // single object per call).
+            function _onData(data) {
+                let str;
+                if (Buffer.isBuffer(data)) {
+                    str = data.toString();
+                } else {
+                     str = data;
+                }
+                str.split(/\r?\n/).forEach(_onLine);
+            }
+
+            function _onLine(line) {
+                jsonLine += line;
+
+                try {
+                    result = JSON.parse(jsonLine);
+                    log.verbose('luna#send()', 'response:', result);
+
+                    jsonLine = "";
+                    if (result.returnValue === false) {
+                        is.destroy();
+                        const errValue = (result.errorText ? result.errorText :
+                                        (result.errorMessage ? result.errorMessage : ''));
+                        next(errHndl.getErrMsg("FAILED_CALL_LUNA", errValue, null, addr.service));
+                    } else {
+                        onResponse(result, function(err, value) {
+                            log.silly('luna#send()', "err:", err, ", value:", value);
+                            if (err || value) {
+                                log.silly('luna#send()', "closing exec stream");
+                                // processing completed or failed
+                                next(err, value);
+                            }
+                        });
+                    }
+                } catch(e) {
+                    // ignore the parsing error:
+                    // the line may be incomplete
+                    // & not yet JSON-parseable
+                }
+            }
+        },
+        sendWithoutErrorHandle: function(options, addr, param, onResponse, next) {
+            const session = options && options.session;
+            // 'is' is used to transmit an EOF to
+            // terminate the remote luna-send.  this is
+            // the only way to terminate an interactive
+            // request 'luna-send -i'...
+            const is = new Eof(),
+                url = ['luna:/', addr.service, addr.folder, addr.method].join('/');
+            let result, mode;
+
+            is.pause();
+            if (options && options.nReplies) {
+                mode = "-n " + options.nReplies + " ";
+            } else {
+                mode = "-i ";
+            }
+
+            log.verbose("luna#sendWithoutErrorHandle()", "calling:", url + " '" + JSON.stringify(param) + "'");
+            session.run(session.getDevice().lunaSend + " " + mode + url + " '" + JSON.stringify(param) + "'", is /* stdin*/, _onData, process.stderr, function(err) {
+                if (err) {
+                    next(err);
+                }
+                // success when the output of the
+                // command is correctly interpreted,
+                // not simply when the command exit
+                // with a success exit code.
+            });
+
+            let jsonLine = "";
+
+            // Break string into lines (JSON.parse needs a
+            // single object per call).
+            function _onData(data) {
+                let str;
+                if (Buffer.isBuffer(data)) {
+                    str = data.toString();
+                } else {
+                     str = data;
+                }
+                str.split(/\r?\n/).forEach(_onLine);
+            }
+
+            function _onLine(line) {
+                jsonLine += line;
+
+                try {
+                    result = JSON.parse(jsonLine);
+                    log.verbose('luna#sendWithoutErrorHandle()', 'response:', result);
+
+                    jsonLine = "";
+                    onResponse(result, function(err, value) {
+                        log.silly('luna#sendWithoutErrorHandle()', "err:", err, ", value:", value);
+                        if (err || value) {
+                            log.silly('luna#sendWithoutErrorHandle()', "closing exec stream");
+                            // processing completed or failed
+                            next(err, value);
+                        }
+                    });
+                } catch(e) {
+                    // ignore the parsing error:
+                    // the line may be incomplete
+                    // & not yet JSON-parseable
+                }
+            }
+        }
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = luna;
+    }
+}());
+