Merge all bin commands into a single command with subcommands

This makes using this module with `npx` much easier

Author: Joris-van-der-Wel

README.md

@@ -11,20 +11,14 @@ First of all, because this project is not an official browser extension yet, you
 
 Then you must make sure that you have node.js installed (version 8 or higher): [https://nodejs.org/en/download/](https://nodejs.org/en/download/).
 
-You can now install Openrunner using your terminal:
+You can open the Openrunner IDE using your terminal:
 
 ```bash
-npm install --global openrunner@latest
-```
-
-Using a different command you can open the Openrunner IDE whenever you would like to use it:
-
-```bash
-openrunner-ide --firefox '/Applications/Firefox Nightly.app/Contents/MacOS/firefox'
+npx openrunner ide --firefox '/Applications/Firefox Nightly.app/Contents/MacOS/firefox'
 ```
 (Update the path to firefox as needed)
 
-After starting you'll see Firefox with an icon of a running person in the menu bar, click this to launch the Openrunner browser extension.
+After executing this command, Firefox will launch and you can click on the Openrunner Icon ![](icons/openrunner-16.png) to start the Openrunner IDE.
 
 Openrunner will launch with a small example script to get you started. The buttons on top of the screen can be used to open or save a script, execute or stop it. The two numbers are for the interval and the amount of runs you'd like to do (by default it's set to 1 run every 60 seconds), the last field is the current status.
 
@@ -35,10 +29,10 @@ The bottom half of the screen shows the result of the run in json-format. Also,
 Much more documentation on how to create scripts is available on the wiki on github: https://github.com/computestdev/Openrunner/wiki/Scripting-guide-(with-examples)
 
 ## Running scripts using your terminal
-Assuming Openrunner has been installed (see [Getting started](#getting-started)), you can run saved scripts using your terminal:
+You can run saved scripts using your terminal:
 
 ```bash
-openrunner --firefox '/Applications/Firefox Nightly.app/Contents/MacOS/firefox' --script myScript.js --result myResult.json --headless
-``` 
+npx openrunner run --firefox '/Applications/Firefox Nightly.app/Contents/MacOS/firefox' --script myScript.js --result myResult.json --headless
+```
 
 After this command has completed, you can inspect/parse all the results in the `myResult.json` file.

bin/_subcommands/build-firefox-mac-bundle.js

@@ -0,0 +1,92 @@
+'use strict';
+const {resolve: resolvePath, join: joinPath} = require('path');
+const fs = require('fs-extra');
+const {JSDOM} = require('jsdom');
+
+const {checkOptionFileAccess, checkOptionIsDirectory} = require('../../lib/node/cli');
+const {version} = require('../../package.json');
+
+const {R_OK, X_OK} = fs.constants;
+const appIcon = require.resolve('../../icons/openrunner.icns');
+const bootstrapScript = `#!/usr/bin/env bash
+MY_PATH="$( cd "$(dirname "$0")" ; pwd -P )"
+"$MY_PATH/firefox" --no-remote --profile "$MY_PATH/../profile" "$@"
+`;
+
+const modifyInfoPlist = async path => {
+    const input = await fs.readFile(path, 'utf8');
+    const dom = new JSDOM(input, {
+        contentType: 'text/xml',
+    });
+    const {document} = dom.window;
+    const findKeyElement = keyName => {
+        return document.evaluate(`/plist/dict/key[text() = "${keyName}"]`, document, null, 9, null).singleNodeValue;
+    };
+    const valueElementForKey = keyName => {
+        // note: injection in the xpath expression here. however we are only using this function by passing our own constant values
+        const keyElement = findKeyElement(keyName);
+        return keyElement.nextElementSibling;
+    };
+    const removeKey = keyName => {
+        const keyElement = findKeyElement(keyName);
+        const valueElement = keyElement.nextElementSibling;
+        keyElement.remove();
+        valueElement.remove();
+    };
+
+    const firefoxVersionElement = valueElementForKey('CFBundleShortVersionString');
+    const firefoxVersion = firefoxVersionElement.textContent;
+    valueElementForKey('CFBundleIdentifier').textContent = `nl.computest.openrunner`;
+    valueElementForKey('CFBundleName').textContent = `Openrunner`;
+    valueElementForKey('CFBundleGetInfoString').textContent = `Openrunner ${version} (F${firefoxVersion})`;
+    valueElementForKey('CFBundleVersion').textContent = version;
+    valueElementForKey('CFBundleExecutable').textContent = 'openrunner';
+    valueElementForKey('CFBundleIconFile').textContent = `openrunner.icns`;
+    removeKey('CFBundleSignature');
+
+    const output = dom.serialize();
+    await fs.writeFile(path, output);
+};
+
+const buildFirefoxMacBundleHandler = async argv => {
+    const optionValidationResults = await Promise.all([
+        checkOptionIsDirectory(argv, 'profile'),
+        checkOptionFileAccess(argv, 'profile', R_OK | X_OK),
+        checkOptionIsDirectory(argv, 'app'),
+        checkOptionFileAccess(argv, 'app', R_OK | X_OK),
+    ]);
+
+    if (!Math.min(...optionValidationResults)) {
+        return 1;
+    }
+
+    const profilePath = resolvePath(argv.profile);
+    const appPath = resolvePath(argv.app);
+    const outputPath = resolvePath(argv.output);
+
+    console.log(
+        '*** Creating a new macOS application bundle with the profile',
+        profilePath,
+        'and firefox application bundle',
+        appPath,
+        'at',
+        outputPath
+    );
+
+    await fs.copy(appPath, outputPath, {preserveTimestamps: true});
+    await Promise.all([
+        fs.copy(profilePath, joinPath(outputPath, 'Contents', 'profile'), {preserveTimestamps: true}),
+        fs.copy(
+            appIcon,
+            joinPath(outputPath, 'Contents', 'Resources', 'openrunner.icns'),
+            {preserveTimestamps: true}
+        ),
+        fs.writeFile(joinPath(outputPath, 'Contents', 'MacOS', 'openrunner'), bootstrapScript, {mode: 0o777}),
+        modifyInfoPlist(joinPath(outputPath, 'Contents', 'Info.plist')),
+    ]);
+
+    console.log('*** Done!');
+    return 0;
+};
+
+exports.handler = buildFirefoxMacBundleHandler;

bin/_subcommands/build-firefox-profile.js

@@ -0,0 +1,19 @@
+'use strict';
+const {resolve: resolvePath} = require('path');
+
+const {buildFirefoxProfile} = require('../..');
+
+const buildFirefoxProfileHandler = async argv => {
+    const inputPath = resolvePath(argv.input);
+    const outputPath = resolvePath(argv.output);
+    console.log('*** Creating a new profile from', inputPath, 'at', outputPath);
+
+    await buildFirefoxProfile({
+        sourceBuildInput: inputPath,
+        outputPath,
+    });
+    console.log('*** Done!');
+    return 0;
+};
+
+exports.handler = buildFirefoxProfileHandler;

bin/_subcommands/build-source.js

@@ -0,0 +1,19 @@
+'use strict';
+const {resolve: resolvePath} = require('path');
+
+const {buildSources} = require('../..');
+
+const buildSourceHandler = async argv => {
+    const outputPath = resolvePath(argv.output);
+    console.log('*** Building sources at', outputPath);
+
+    await buildSources({
+        outputPath,
+        cncPort: argv.cncPort,
+        instrumentCoverage: argv.coverage,
+    });
+    console.log('*** Done!');
+    return 0;
+};
+
+exports.handler = buildSourceHandler;

bin/_subcommands/ide.js

@@ -0,0 +1,37 @@
+'use strict';
+const {resolve: resolvePath} = require('path');
+const fs = require('fs-extra');
+const Promise = require('bluebird');
+
+const {checkOptionFileAccess, checkOptionIsFile, checkOptionIsDirectory} = require('../../lib/node/cli');
+const {buildTempFirefoxProfile} = require('../../building');
+const {startFirefox} = require('../../lib/node/firefoxProcess');
+
+const {R_OK, X_OK, W_OK} = fs.constants;
+
+const ideHandler = async argv => {
+    const optionValidationResults = await Promise.all([
+        checkOptionIsFile(argv, 'firefox'),
+        checkOptionFileAccess(argv, 'firefox', R_OK | X_OK),
+        checkOptionIsDirectory(argv, 'tmp'),
+        checkOptionFileAccess(argv, 'tmp', R_OK | W_OK | X_OK),
+    ]);
+
+    if (!Math.min(...optionValidationResults)) {
+        return 1;
+    }
+
+    const tempDirectory = resolvePath(argv.tmp);
+    const firefoxPath = resolvePath(argv.firefox);
+    const profileOptions = {tempDirectory};
+
+    await Promise.using(buildTempFirefoxProfile(profileOptions), async profilePath => {
+        return await Promise.using(startFirefox({firefoxPath, profilePath}), async firefoxProcess => {
+            await firefoxProcess.waitForChildStop();
+        });
+    });
+
+    return 0;
+};
+
+exports.handler = ideHandler;

bin/_subcommands/run.js

@@ -0,0 +1,92 @@
+'use strict';
+const {resolve: resolvePath, basename} = require('path');
+const fs = require('fs-extra');
+const Promise = require('bluebird');
+
+const {CnCServer} = require('../..');
+const {buildTempFirefoxProfile, buildCachedTempFirefoxProfile} = require('../../building');
+const {checkOptionFileAccess, checkOptionIsFile, checkOptionIsDirectory} = require('../../lib/node/cli');
+const {ERROR_FAILED_TO_CREATE_PROFILE_CACHE, startFirefox} = require('../../lib/node/firefoxProcess');
+const {ERROR_FAILED_TO_OPEN_RESULT_FILE, resultFileOutput} = require('../../lib/node/runResult');
+const log = require('../../lib/logger')({MODULE: 'bin/openrunner'});
+
+const {R_OK, X_OK, W_OK} = fs.constants;
+
+const runHandler = async argv => {
+    try {
+        const optionValidationResults = await Promise.all([
+            checkOptionIsFile(argv, 'firefox'),
+            checkOptionFileAccess(argv, 'firefox', R_OK | X_OK),
+            checkOptionIsFile(argv, 'script'),
+            checkOptionFileAccess(argv, 'script', R_OK),
+            checkOptionIsDirectory(argv, 'tmp'),
+            checkOptionFileAccess(argv, 'tmp', R_OK | W_OK | X_OK),
+        ]);
+
+        if (!Math.min(...optionValidationResults)) {
+            return 1;
+        }
+
+        if (argv.cncPort < 1 && argv.profileCache) {
+            // cncPort=0 means that the OS will pick any unused one. And since we have to hard code
+            // the cncPort into the profile, the cache would be useless
+            console.error('The --profileCache option may not be used if the --cncPort option is set to 0');
+            return 1;
+        }
+
+        const {cncPort, result: resultFile, headless} = argv;
+        const tempDirectory = resolvePath(argv.tmp);
+        const firefoxPath = resolvePath(argv.firefox);
+        const scriptFile = resolvePath(argv.script);
+        const profileCache = argv.profileCache && resolvePath(argv.profileCache);
+        const scriptContent = await fs.readFile(scriptFile, 'utf8');
+        const stackFileName = basename(scriptFile);
+
+        const startAndRunScript = async ({profilePath, cncServer}) => {
+            return await Promise.using(startFirefox({firefoxPath, profilePath, headless}), async () => {
+                log.debug('Waiting for C&C connection...');
+                await cncServer.waitForActiveConnection();
+                log.info({stackFileName}, 'Sending runScript command...');
+                return await cncServer.runScript({scriptContent, stackFileName});
+            });
+        };
+
+        // open the result file before starting the script, so that we catch errors early
+        await Promise.using(resultFileOutput(resultFile), CnCServer.promiseDisposer(cncPort), async (writeResultFile, cncServer) => {
+            const profileOptions = {tempDirectory, cncPort: cncServer.listenPort, profileCache};
+
+            let scriptResult;
+            if (profileCache) {
+                const profilePath = await buildCachedTempFirefoxProfile({tempDirectory, cncPort: cncServer.listenPort, profileCache});
+                scriptResult = await startAndRunScript({profilePath, cncServer});
+            }
+            else {
+                scriptResult = await Promise.using(buildTempFirefoxProfile(profileOptions), async profilePath => {
+                    return await startAndRunScript({profilePath, cncServer});
+                });
+            }
+
+            log.info({stackFileName}, 'Script run completed');
+            if (writeResultFile) {
+                await writeResultFile(JSON.stringify(scriptResult, null, 4));
+            }
+        });
+
+        return 0;
+    }
+    catch (err) {
+        if (err[ERROR_FAILED_TO_OPEN_RESULT_FILE]) {
+            console.error(`Invalid value for option --result : ${err.message}`);
+            return 1;
+        }
+
+        if (err[ERROR_FAILED_TO_CREATE_PROFILE_CACHE]) {
+            console.error(`Invalid value for option --profileCache : ${err.message}`);
+            return 1;
+        }
+
+        throw err;
+    }
+};
+
+exports.handler = runHandler;