@criticalmanufacturing/cli 2.0.0-3

package/README.md

@@ -0,0 +1,29 @@
+# CMF Command Line tool
+
+WARNING: cmf-cli is alpha software. Buckle up.
+
+## Installing
+
+```
+npm install --global @criticalmanufacturing/cli
+```
+
+
+After installation, a new command `cmf` will be added to your PATH.
+
+## Commands
+
+The tool includes a help feature which details the available commands. Run
+
+```
+cmf
+```
+
+to get more information. Feature sets also have help menus, e.g.:
+
+```
+cmf -h
+```
+
+Full documentation in [docs](https://github.com/criticalmanufacturing/cli/tree/main/docs)
+

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@criticalmanufacturing/cli",
+  "version": "2.0.0-3",
+  "description": "Critical Manufacturing command line client",
+  "bin": {
+    "cmf": "./run.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js install",
+    "preuninstall": "node postinstall.js uninstall"
+  },
+  "author": "Critical Manufacturing, SA",
+  "license": "BSD-3-Clause",
+  "goBinary": {
+    "name": "cmf",
+    "path": "./bin",
+    "url": "https://github.com/criticalmanufacturing/cli/releases/download/{{version}}/cmf-cli.{{platform}}-{{arch}}.zip"
+  },
+  "homepage": "https://github.com/criticalmanufacturing/cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/criticalmanufacturing/cli.git"
+  },
+  "files": [
+    "dist",
+    "postinstall.js",
+    "run.js",
+    "utils.js"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.5",
+    "axios": "^0.21.1",
+    "debug": "^4.3.1",
+    "env-paths": "^2.2.1",
+    "is-installed-globally": "^0.4.0",
+    "mkdirp": "^1.0.4",
+    "node_modules-path": "^2.0.5",
+    "rimraf": "^3.0.2",
+    "tmp": "^0.2.1"
+  }
+}

package/postinstall.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const path = require('path'),
+    mkdirp = require('mkdirp'),
+    envPaths = require('env-paths'),
+    rimraf = require('rimraf'),
+    fs = require('fs'),
+    axios = require('axios'),
+    AdmZip = require("adm-zip"),
+    tmp = require('tmp'),
+    dbg= require('debug'),
+    node_modules = require('node_modules-path'),
+    { parsePackageJson, PLATFORM_MAPPING, ARCH_MAPPING } = require('./utils');
+
+
+const debug = dbg("cmf:debug");
+const error = dbg("cmf:debug:error");
+
+async function getInstallationPath() {
+    debug("Getting installation path...");
+    if (!!process.env.npm_config_global) {
+        debug("Install is global, so targeting home directory for binaries");
+        // install into home:
+        // win: /AppData/Local/CMF/cmf-cli
+        // linux: ~/.local/share/cmf-cli
+        // osx: ~/Library/Application Support/cmf-cli
+        const paths = envPaths("cmf-cli", {suffix: ""});
+        debug(`Install at ${paths.data}. Making sure path exists...`);
+        await mkdirp(paths.data);
+        debug(`Install path exists!`);
+        return paths.data;
+    } else {
+        debug("Install is local, so targeting node_modules/.bin/cmf-cli. Making sure path exists...");
+        // install into node_modules/.bin/cmf-cli
+        const value = path.join(node_modules(), ".bin");
+        const dir = path.join(value, "cmf-cli");
+        await mkdirp(dir);
+        debug(`Install path exists!`);
+        return dir;
+    }
+}
+
+async function verifyAndPlaceBinary(binName, binPath, callback) {
+    if (!fs.existsSync(path.join(binPath, binName))) return callback('Downloaded binary does not contain the binary specified in configuration - ' + binName);
+    return callback(null);
+}
+
+/**
+ * Reads the configuration from application's package.json,
+ * validates properties, copied the binary from the package and stores at
+ * ./bin in the package's root. NPM already has support to install binary files
+ * specific locations when invoked with "npm install -g"
+ *
+ *  See: https://docs.npmjs.com/files/package.json#bin
+ */
+var INVALID_INPUT = "Invalid inputs";
+async function install(callback) {
+
+    var opts = parsePackageJson(".");
+    if (!opts) return callback(INVALID_INPUT);
+    console.info(`Copying the relevant binary for your platform ${process.platform}`);
+    const src= `./dist/${PLATFORM_MAPPING[process.platform]}-${ARCH_MAPPING[process.arch]}`;
+
+    if (!fs.existsSync("./dist")) {
+        // download respective release zip from github
+        const pkgUrl = opts.binUrl.replace("{{version}}", opts.version).replace("{{platform}}", PLATFORM_MAPPING[process.platform]).replace("{{arch}}", ARCH_MAPPING[process.arch]);
+        console.info(`Getting release archive from ${pkgUrl} into ${path.resolve(src)}`);
+        try {
+            const response = await axios({
+                url: pkgUrl,
+                method: 'GET',
+                responseType: 'arraybuffer', // to do this with streaming we must deal with chunking
+            });
+            const zip = tmp.tmpNameSync();
+            debug(`Writing temporary zip file to ${zip}`);
+            fs.writeFileSync(zip, response.data);
+            debug(`Extracting zip file ${zip} to ${src}`);
+            (new AdmZip(zip)).extractAllTo(src);
+        } catch (e) {
+            error(e);
+            callback(`Could not install version ${opts.version} on your platform ${process.platform}/${process.arch}: ${e.message}`);
+        }
+    }
+
+    const installPath = await getInstallationPath();
+    if (process.platform === "win32") {
+        debug("Installing for windows");
+        await execShellCommand(`robocopy ${src.replace(/\//g, "\\")} "${installPath}" /e /is /it`, [1]);
+    } else {
+        debug("Installing for *NIX: " + process.platform);
+        await execShellCommand(`cp -r ${src}/** "${installPath}"`);
+        await execShellCommand(`chmod +x "${installPath}/cmf"`);
+    }
+    
+    await verifyAndPlaceBinary(opts.binName, installPath, callback);
+}
+
+async function uninstall(callback) {
+    var opts = parsePackageJson(".");
+    try {
+        const installationPath = await getInstallationPath();
+        debug("Deleting binaries from " + installationPath);
+        rimraf.sync(installationPath);
+    } catch (ex) {
+        console.log(ex);
+        callback(ex);
+        // Ignore errors when deleting the file.
+    }
+    console.info("Uninstalled cli successfully");
+    return callback(null);
+}
+
+// Parse command line arguments and call the right method
+var actions = {
+    "install": install,
+    "uninstall": uninstall
+};
+/**
+ * Executes a shell command and return it as a Promise.
+ * @param cmd {string}
+ * @return {Promise<string>}
+ */
+function execShellCommand(cmd, valid_error_codes = null) {
+    const exec = require('child_process').exec;
+    return new Promise((resolve, reject) => {
+        exec(cmd, (error, stdout, stderr) => {
+            if (error) {
+                let shouldPrint = true;
+                if (valid_error_codes != null) {
+                    shouldPrint = valid_error_codes.indexOf(error.code) < 0;
+                }
+                shouldPrint && console.warn(error);
+            }
+            resolve(stdout? stdout : stderr);
+        });
+    });
+}
+
+var argv = process.argv;
+if (argv && argv.length > 2) {
+    var cmd = process.argv[2];
+    if (!actions[cmd]) {
+        console.log("Invalid command. `install` and `uninstall` are the only supported commands");
+        process.exit(1);
+    }
+
+    actions[cmd](function (err) {
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        } else {
+            process.exit(0);
+        }
+    });
+}

package/run.js

@@ -0,0 +1,33 @@
+#! /usr/bin/env node
+"use strict";
+const { spawn } = require('child_process');
+const envPaths = require('env-paths');
+const path = require('path');
+const fs = require('fs');
+const isInstalledGlobally = require('is-installed-globally');
+const node_modules = require('node_modules-path');
+const dbg = require('debug');
+const { parsePackageJson, ARCH_MAPPING, PLATFORM_MAPPING } = require('./utils');
+
+const opts = parsePackageJson(__dirname);
+const debug = dbg("cmf:debug");
+
+debug("Executing cmf-cli");
+let exePath = null;
+debug("Determining if cli is installed globally or locally...");
+if (isInstalledGlobally) {
+  debug("cli is installed globally. Getting binary location from user profile...");
+  const paths = envPaths("cmf-cli", {suffix: ""});
+  exePath = path.join(paths.data, opts.binName);
+} else {
+  debug("cli is installed locally. Getting binary from node_modules/.bin/cmf-cli...");
+  exePath = path.join(node_modules(), ".bin", "cmf-cli", opts.binName);
+}
+debug("Obtained binary path: " + exePath);
+
+debug(`Spawning cmf-cli from ${exePath} with args ${process.argv.slice(2)} and piping.`);
+const child = spawn(exePath, process.argv.slice(2), {stdio: "inherit"});
+child.on('close', (code) => {
+  debug("Process exited with code " + code);
+  process.exitCode = code;
+});

package/utils.js

@@ -0,0 +1,89 @@
+// Thanks to author of https://github.com/sanathkr/go-npm, we were able to modify his code to work with private packages
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+const path = require('path');
+const fs = require('fs');
+
+// Mapping from Node's `process.arch` to dotnet's `RID`
+var ARCH_MAPPING = {
+    "ia32": "x86",
+    "x64": "x64",
+    // "arm": "arm" - linux RID? can only find win-arm which is not useful
+};
+
+// Mapping between Node's `process.platform` to dotnet's RID
+var PLATFORM_MAPPING = {
+    "darwin": "osx",
+    "linux": "linux",
+    "win32": "win"
+};
+
+function validateConfiguration(packageJson) {
+
+    if (!packageJson.version) {
+        return "'version' property must be specified";
+    }
+
+    if (!packageJson.goBinary || _typeof(packageJson.goBinary) !== "object") {
+        return "'goBinary' property must be defined and be an object";
+    }
+
+    if (!packageJson.goBinary.name) {
+        return "'name' property is necessary";
+    }
+
+    if (!packageJson.goBinary.path) {
+        return "'path' property is necessary";
+    }
+}
+
+function parsePackageJson(root) {
+    if (!(process.arch in ARCH_MAPPING)) {
+        console.error("Installation is not supported for this architecture: " + process.arch);
+        return;
+    }
+
+    if (!(process.platform in PLATFORM_MAPPING)) {
+        console.error("Installation is not supported for this platform: " + process.platform);
+        return;
+    }
+
+    var packageJsonPath = path.join(root, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error("Unable to find package.json. " + "Please run this script at root of the package you want to be installed");
+        return;
+    }
+
+    var packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+    var error = validateConfiguration(packageJson);
+    if (error && error.length > 0) {
+        console.error("Invalid package.json: " + error);
+        return;
+    }
+
+    // We have validated the config. It exists in all its glory
+    var binName = packageJson.goBinary.name;
+    var binPath = packageJson.goBinary.path;
+    var binUrl = packageJson.goBinary.url;
+    var version = packageJson.version;
+    if (version[0] === 'v') version = version.substr(1); // strip the 'v' if necessary v0.0.1 => 0.0.1
+
+    // Binary name on Windows has .exe suffix
+    if (process.platform === "win32") {
+        binName += ".exe";
+    }
+
+
+    return {
+        binName: binName,
+        binPath: binPath,
+        binUrl: binUrl,
+        version: version
+    };
+}
+
+module.exports = {
+    parsePackageJson,
+    ARCH_MAPPING,
+    PLATFORM_MAPPING
+}