Last commit july 5th

spa/node_modules/cordova/src/cli.js

@@ -0,0 +1,447 @@
+/**
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+*/
+
+const nopt = require('nopt');
+const pkg = require('../package.json');
+const telemetry = require('./telemetry');
+const help = require('./help');
+const info = require('./info');
+const cordova_lib = require('cordova-lib');
+const CordovaError = cordova_lib.CordovaError;
+const cordova = cordova_lib.cordova;
+const events = cordova_lib.events;
+const logger = require('cordova-common').CordovaLogger.get();
+const cordovaCreate = require('cordova-create');
+const Configstore = require('configstore');
+const conf = new Configstore(pkg.name + '-config');
+const editor = require('editor');
+const semver = require('semver');
+
+// process.version is not declared writable or has no setter so storing in const for Jasmine.
+const NODE_VERSION = process.version;
+
+// When there is no node version in the deprecation stage, set to null or false.
+const NODE_VERSION_REQUIREMENT = false;
+const NODE_VERSION_DEPRECATING_RANGE = '<10';
+
+const knownOpts = {
+    verbose: Boolean,
+    version: Boolean,
+    help: Boolean,
+    silent: Boolean,
+    experimental: Boolean,
+    noregistry: Boolean,
+    nohooks: Array,
+    shrinkwrap: Boolean,
+    searchpath: String,
+    variable: Array,
+    link: Boolean,
+    force: Boolean,
+    'save-exact': Boolean,
+    // Flags to be passed to `cordova build/run/emulate`
+    debug: Boolean,
+    release: Boolean,
+    archs: String,
+    device: Boolean,
+    emulator: Boolean,
+    target: String,
+    noprepare: Boolean,
+    nobuild: Boolean,
+    list: Boolean,
+    buildConfig: String,
+    template: String,
+    production: Boolean,
+    noprod: Boolean
+};
+
+const shortHands = {
+    d: '--verbose',
+    v: '--version',
+    h: '--help',
+    t: '--template'
+};
+
+let shouldCollectTelemetry = false;
+
+module.exports = function (inputArgs) {
+    // If no inputArgs given, use process.argv.
+    inputArgs = inputArgs || process.argv;
+    let cmd = inputArgs[2]; // e.g: inputArgs= 'node cordova run ios'
+    const subcommand = getSubCommand(inputArgs, cmd);
+    const isTelemetryCmd = (cmd === 'telemetry');
+    const isConfigCmd = (cmd === 'config');
+
+    // ToDO: Move nopt-based parsing of args up here
+    if (cmd === '--version' || cmd === '-v') {
+        cmd = 'version';
+    } else if (!cmd || cmd === '--help' || cmd === 'h') {
+        cmd = 'help';
+    }
+
+    // If "get" is called
+    if (isConfigCmd && inputArgs[3] === 'get') {
+        if (inputArgs[4]) {
+            logger.subscribe(events);
+            conf.get(inputArgs[4]);
+            if (conf.get(inputArgs[4]) !== undefined) {
+                events.emit('log', conf.get(inputArgs[4]).toString());
+            } else {
+                events.emit('log', 'undefined');
+            }
+        }
+    }
+
+    // If "set" is called
+    if (isConfigCmd && inputArgs[3] === 'set') {
+        if (inputArgs[5] === undefined) {
+            conf.set(inputArgs[4], true);
+        }
+
+        if (inputArgs[5]) {
+            conf.set(inputArgs[4], inputArgs[5]);
+        }
+    }
+
+    // If "delete" is called
+    if (isConfigCmd && inputArgs[3] === 'delete') {
+        if (inputArgs[4]) {
+            conf.del(inputArgs[4]);
+        }
+    }
+
+    // If "edit" is called
+    if (isConfigCmd && inputArgs[3] === 'edit') {
+        editor(conf.path, function (code, sig) {
+            logger.warn('Finished editing with code ' + code);
+        });
+    }
+
+    // If "ls" is called
+    if (isConfigCmd && (inputArgs[3] === 'ls' || inputArgs[3] === 'list')) {
+        logger.results(JSON.stringify(conf.all, null, 4));
+    }
+
+    return Promise.resolve().then(function () {
+        /**
+         * Skip telemetry prompt if:
+         * - CI environment variable is present
+         * - Command is run with `--no-telemetry` flag
+         * - Command ran is: `cordova telemetry on | off | ...`
+         */
+
+        if (telemetry.isCI(process.env) || telemetry.isNoTelemetryFlag(inputArgs)) {
+            return Promise.resolve(false);
+        }
+
+        /**
+         * We shouldn't prompt for telemetry if user issues a command of the form: `cordova telemetry on | off | ...x`
+         * Also, if the user has already been prompted and made a decision, use his saved answer
+         */
+        if (isTelemetryCmd) {
+            const isOptedIn = telemetry.isOptedIn();
+            return handleTelemetryCmd(subcommand, isOptedIn);
+        }
+
+        if (telemetry.hasUserOptedInOrOut()) {
+            return Promise.resolve(telemetry.isOptedIn());
+        }
+
+        /**
+         * Otherwise, prompt user to opt-in or out
+         * Note: the prompt is shown for 30 seconds. If no choice is made by that time, User is considered to have opted out.
+         */
+        return telemetry.showPrompt();
+    }).then(function (collectTelemetry) {
+        shouldCollectTelemetry = collectTelemetry;
+        if (isTelemetryCmd) {
+            return Promise.resolve();
+        }
+        return cli(inputArgs);
+    }).then(function () {
+        if (shouldCollectTelemetry && !isTelemetryCmd) {
+            telemetry.track(cmd, subcommand, 'successful');
+        }
+    }).catch(function (err) {
+        if (shouldCollectTelemetry && !isTelemetryCmd) {
+            telemetry.track(cmd, subcommand, 'unsuccessful');
+        }
+        throw err;
+    });
+};
+
+function getSubCommand (args, cmd) {
+    if (['platform', 'platforms', 'plugin', 'plugins', 'telemetry', 'config'].indexOf(cmd) > -1) {
+        return args[3]; // e.g: args='node cordova platform rm ios', 'node cordova telemetry on'
+    }
+    return null;
+}
+
+function printHelp (command) {
+    const result = help([command]);
+    cordova.emit('results', result);
+}
+
+function handleTelemetryCmd (subcommand, isOptedIn) {
+    if (subcommand !== 'on' && subcommand !== 'off') {
+        logger.subscribe(events);
+        printHelp('telemetry');
+        return;
+    }
+
+    const turnOn = subcommand === 'on';
+    let cmdSuccess = true;
+
+    // turn telemetry on or off
+    try {
+        if (turnOn) {
+            telemetry.turnOn();
+            console.log('Thanks for opting into telemetry to help us improve cordova.');
+        } else {
+            telemetry.turnOff();
+            console.log('You have been opted out of telemetry. To change this, run: cordova telemetry on.');
+        }
+    } catch (ex) {
+        cmdSuccess = false;
+    }
+
+    // track or not track ?, that is the question
+
+    if (!turnOn) {
+        // Always track telemetry opt-outs (whether user opted out or not!)
+        telemetry.track('telemetry', 'off', 'via-cordova-telemetry-cmd', cmdSuccess ? 'successful' : 'unsuccessful');
+        return Promise.resolve();
+    }
+
+    if (isOptedIn) {
+        telemetry.track('telemetry', 'on', 'via-cordova-telemetry-cmd', cmdSuccess ? 'successful' : 'unsuccessful');
+    }
+
+    return Promise.resolve();
+}
+
+function cli (inputArgs) {
+    const args = nopt(knownOpts, shortHands, inputArgs);
+
+    process.on('uncaughtException', function (err) {
+        if (err.message) {
+            logger.error(err.message);
+        } else {
+            logger.error(err);
+        }
+        // Don't send exception details, just send that it happened
+        if (shouldCollectTelemetry) {
+            telemetry.track('uncaughtException');
+        }
+        process.exit(1);
+    });
+
+    logger.subscribe(events);
+
+    if (args.silent) {
+        logger.setLevel('error');
+    } else if (args.verbose) { // can't be both silent AND verbose, silent wins
+        logger.setLevel('verbose');
+    }
+
+    const cliVersion = pkg.version;
+    const usingPrerelease = !!semver.prerelease(cliVersion);
+    if (args.version || usingPrerelease) {
+        const libVersion = require('cordova-lib/package').version;
+        let toPrint = cliVersion;
+        if (cliVersion !== libVersion || usingPrerelease) {
+            toPrint += ' (cordova-lib@' + libVersion + ')';
+        }
+
+        if (args.version) {
+            logger.results(toPrint);
+            return Promise.resolve(); // Important! this will return and cease execution
+        } else { // must be usingPrerelease
+            // Show a warning and continue
+            logger.warn('Warning: using prerelease version ' + toPrint);
+        }
+    }
+
+    let warningPartial = null;
+
+    // If the Node.js versions does not meet our requirements or in a deprecation stage, display a warning.
+    if (
+        NODE_VERSION_REQUIREMENT &&
+        !semver.satisfies(NODE_VERSION, NODE_VERSION_REQUIREMENT)
+    ) {
+        warningPartial = 'is no longer supported';
+    } else if (
+        NODE_VERSION_DEPRECATING_RANGE &&
+        semver.satisfies(NODE_VERSION, NODE_VERSION_DEPRECATING_RANGE)
+    ) {
+        warningPartial = 'has been deprecated';
+    }
+
+    if (warningPartial) {
+        const upgradeMsg = 'Please upgrade to the latest Node.js version available (LTS version recommended).';
+        logger.warn(`Warning: Node.js ${NODE_VERSION} ${warningPartial}. ${upgradeMsg}`);
+    }
+
+    // If there were arguments protected from nopt with a double dash, keep
+    // them in unparsedArgs. For example:
+    // cordova build ios -- --verbose --whatever
+    // In this case "--verbose" is not parsed by nopt and args.vergbose will be
+    // false, the unparsed args after -- are kept in unparsedArgs and can be
+    // passed downstream to some scripts invoked by Cordova.
+    let unparsedArgs = [];
+    const parseStopperIdx = args.argv.original.indexOf('--');
+    if (parseStopperIdx !== -1) {
+        unparsedArgs = args.argv.original.slice(parseStopperIdx + 1);
+    }
+
+    // args.argv.remain contains both the undashed args (like platform names)
+    // and whatever unparsed args that were protected by " -- ".
+    // "undashed" stores only the undashed args without those after " -- " .
+    const remain = args.argv.remain;
+    const undashed = remain.slice(0, remain.length - unparsedArgs.length);
+    const cmd = undashed[0];
+    let subcommand;
+
+    if (!cmd || cmd === 'help' || args.help) {
+        if (!args.help && remain[0] === 'help') {
+            remain.shift();
+        }
+        return printHelp(remain);
+    }
+
+    if (cmd === 'info') return info();
+
+    // Don't need to do anything with cordova-lib since config was handled above
+    if (cmd === 'config') return true;
+
+    if (cmd === 'create') {
+        const [, dest, id, name] = undashed;
+        return cordovaCreate(dest, { id, name, events, template: args.template });
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(cordova, cmd)) {
+        const msg2 = 'Cordova does not know ' + cmd + '; try `' + cordova_lib.binname +
+            ' help` for a list of all the available commands.';
+        throw new CordovaError(msg2);
+    }
+
+    const opts = {
+        platforms: [],
+        options: [],
+        verbose: args.verbose || false,
+        silent: args.silent || false,
+        nohooks: args.nohooks || [],
+        searchpath: args.searchpath
+    };
+
+    const platformCommands = ['emulate', 'build', 'prepare', 'compile', 'run', 'clean'];
+    if (platformCommands.indexOf(cmd) !== -1) {
+        // All options without dashes are assumed to be platform names
+        opts.platforms = undashed.slice(1);
+
+        // Pass nopt-parsed args to PlatformApi through opts.options
+        opts.options = args;
+        opts.options.argv = unparsedArgs;
+
+        return cordova[cmd].call(null, opts);
+    } else if (cmd === 'requirements') {
+        // All options without dashes are assumed to be platform names
+        opts.platforms = undashed.slice(1);
+
+        return cordova[cmd].call(null, opts.platforms)
+            .then(function (platformChecks) {
+                const someChecksFailed = Object.keys(platformChecks).map(function (platformName) {
+                    events.emit('log', '\nRequirements check results for ' + platformName + ':');
+                    const platformCheck = platformChecks[platformName];
+                    if (platformCheck instanceof CordovaError) {
+                        events.emit('warn', 'Check failed for ' + platformName + ' due to ' + platformCheck);
+                        return true;
+                    }
+
+                    let someChecksFailed = false;
+
+                    // platformCheck is expected to be an array of conditions that must be met
+                    // the browser platform currently returns nothing, which was breaking here.
+                    if (platformCheck && platformCheck.forEach) {
+                        platformCheck.forEach(function (checkItem) {
+                            const checkSummary = checkItem.name + ': ' +
+                                (checkItem.installed ? 'installed ' : 'not installed ') +
+                                (checkItem.installed ? checkItem.metadata.version.version || checkItem.metadata.version : '');
+                            events.emit('log', checkSummary);
+                            if (!checkItem.installed) {
+                                someChecksFailed = true;
+                                events.emit('warn', checkItem.metadata.reason);
+                            }
+                        });
+                    }
+                    return someChecksFailed;
+                }).some(function (isCheckFailedForPlatform) {
+                    return isCheckFailedForPlatform;
+                });
+
+                if (someChecksFailed) {
+                    throw new CordovaError('Some of requirements check failed');
+                }
+            });
+    } else if (cmd === 'serve') {
+        const port = undashed[1];
+        return cordova.serve(port);
+    } else {
+        // platform/plugins add/rm [target(s)]
+        subcommand = undashed[1]; // sub-command like "add", "ls", "rm" etc.
+        const targets = undashed.slice(2); // array of targets, either platforms or plugins
+        const cli_vars = {};
+        if (args.variable) {
+            args.variable.forEach(function (strVar) {
+                // CB-9171
+                const keyVal = strVar.split('=');
+                if (keyVal.length < 2) {
+                    throw new CordovaError('invalid variable format: ' + strVar);
+                } else {
+                    const key = keyVal.shift().toUpperCase();
+                    const val = keyVal.join('=');
+                    cli_vars[key] = val;
+                }
+            });
+        }
+
+        args.save = !args.nosave;
+        args.production = !args.noprod;
+
+        if (args.searchpath === undefined) {
+            // User explicitly did not pass in searchpath
+            args.searchpath = conf.get('searchpath');
+        }
+        if (args['save-exact'] === undefined) {
+            // User explicitly did not pass in save-exact
+            args['save-exact'] = conf.get('save-exact');
+        }
+
+        const download_opts = {
+            searchpath: args.searchpath,
+            noregistry: args.noregistry,
+            nohooks: args.nohooks,
+            cli_variables: cli_vars,
+            link: args.link || false,
+            save: args.save,
+            save_exact: args['save-exact'] || false,
+            shrinkwrap: args.shrinkwrap || false,
+            force: args.force || false,
+            production: args.production
+        };
+        return cordova[cmd](subcommand, targets, download_opts);
+    }
+}

spa/node_modules/cordova/src/help.js

@@ -0,0 +1,41 @@
+/**
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+*/
+const fs = require('fs');
+const cordova_lib = require('cordova-lib');
+const path = require('path');
+
+module.exports = function help (args) {
+    args = args || [];
+
+    const command = ((args)[0] || 'cordova');
+    const docdir = path.join(__dirname, '..', 'doc');
+    const file = [
+        `${command}.md`,
+        `${command}.txt`,
+        'cordova.md',
+        'cordova.txt'
+    ]
+        .map(f => path.join(docdir, f))
+        .filter(f => !!fs.existsSync(f));
+
+    const raw = fs.readFileSync(file[0]).toString('utf8').replace(/cordova-cli/g, cordova_lib.binname);
+    // cordova.emit('results', raw);
+
+    return raw;
+};

spa/node_modules/cordova/src/info.js

@@ -0,0 +1,224 @@
+/**
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+*/
+
+const path = require('path');
+const fs = require('fs-extra');
+const execa = require('execa');
+const { osInfo } = require('systeminformation');
+const { cordova, cordova_platforms: { getPlatformApi } } = require('cordova-lib');
+
+const cdvLibUtil = require('cordova-lib/src/cordova/util');
+const cdvPluginUtil = require('cordova-lib/src/cordova/plugin/util');
+
+// Cache
+let _installedPlatformsList = null;
+
+/*
+ * Sections
+ */
+
+async function getCordovaDependenciesInfo () {
+    // get self "Cordova CLI"
+    const cliPkg = require('../package');
+    const cliDependencies = await _getLibDependenciesInfo(cliPkg.dependencies);
+
+    const libPkg = require('cordova-lib/package');
+    const cliLibDep = cliDependencies.find(({ key }) => key === 'lib');
+    cliLibDep.children = await _getLibDependenciesInfo(libPkg.dependencies);
+
+    return {
+        key: 'Cordova Packages',
+        children: [{
+            key: 'cli',
+            value: cliPkg.version,
+            children: cliDependencies
+        }]
+    };
+}
+
+async function getInstalledPlatforms (projectRoot) {
+    return _getInstalledPlatforms(projectRoot).then(platforms => {
+        const key = 'Project Installed Platforms';
+        const children = Object.entries(platforms)
+            .map(([key, value]) => ({ key, value }));
+
+        return { key, children };
+    });
+}
+
+async function getInstalledPlugins (projectRoot) {
+    const key = 'Project Installed Plugins';
+    const children = cdvPluginUtil.getInstalledPlugins(projectRoot)
+        .map(plugin => ({ key: plugin.id, value: plugin.version }));
+
+    return { key, children };
+}
+
+async function getEnvironmentInfo () {
+    const [npmVersion, osInfoResult] = await Promise.all([_getNpmVersion(), osInfo()]);
+    const { platform, distro, release, codename, kernel, arch, build } = osInfoResult;
+
+    const optionalBuildSuffix = build ? ` (${build})` : '';
+
+    const osFormat = [
+        platform === 'darwin' ? codename : distro,
+        release + optionalBuildSuffix,
+        `(${platform} ${kernel})`,
+        `${arch}`
+    ];
+
+    return {
+        key: 'Environment',
+        children: [
+            { key: 'OS', value: osFormat.join(' ') },
+            { key: 'Node', value: process.version },
+            { key: 'npm', value: npmVersion }
+        ]
+    };
+}
+
+async function getPlatformEnvironmentData (projectRoot) {
+    const installedPlatforms = await _getInstalledPlatforms(projectRoot);
+
+    return Object.keys(installedPlatforms)
+        .map(platform => {
+            const platformApi = getPlatformApi(platform);
+
+            const getPlatformInfo = platformApi && platformApi.getEnvironmentInfo
+                ? () => platformApi.getEnvironmentInfo()
+                : _legacyPlatformInfo[platform];
+
+            return { platform, getPlatformInfo };
+        })
+        .filter(o => o.getPlatformInfo)
+        .map(async ({ platform, getPlatformInfo }) => ({
+            key: `${platform} Environment`,
+            children: await getPlatformInfo()
+        }));
+}
+
+async function getProjectSettingsFiles (projectRoot) {
+    const cfgXml = _fetchFileContents(cdvLibUtil.projectConfig(projectRoot));
+
+    // Create package.json snippet
+    const pkgJson = require(path.join(projectRoot, 'package'));
+    const pkgSnippet = [
+        '--- Start of Cordova JSON Snippet ---',
+        JSON.stringify(pkgJson.cordova, null, 2),
+        '--- End of Cordova JSON Snippet ---'
+    ].join('\n');
+
+    return {
+        key: 'Project Setting Files',
+        children: [
+            { key: 'config.xml', value: `${cfgXml}` },
+            { key: 'package.json', value: pkgSnippet }
+        ]
+    };
+}
+
+/*
+ * Section Data Helpers
+ */
+
+async function _getLibDependenciesInfo (dependencies) {
+    const cordovaPrefix = 'cordova-';
+    const versionFor = name => require(`${name}/package`).version;
+
+    return Object.keys(dependencies)
+        .filter(name => name.startsWith(cordovaPrefix))
+        .map(name => ({ key: name.slice(cordovaPrefix.length), value: versionFor(name) }));
+}
+
+async function _getInstalledPlatforms (projectRoot) {
+    if (!_installedPlatformsList) {
+        _installedPlatformsList = await cdvLibUtil.getInstalledPlatformsWithVersions(projectRoot);
+    }
+    return _installedPlatformsList;
+}
+
+async function _getNpmVersion () {
+    return (await execa('npm', ['-v'])).stdout;
+}
+
+function _fetchFileContents (filePath) {
+    if (!fs.existsSync(filePath)) return 'File Not Found';
+
+    return fs.readFileSync(filePath, 'utf-8');
+}
+
+/**
+ * @deprecated will be removed when platforms implement the calls.
+ */
+const _legacyPlatformInfo = {
+    ios: async () => [{
+        key: 'xcodebuild',
+        value: await _failSafeSpawn('xcodebuild', ['-version'])
+    }],
+    android: async () => [{
+        key: 'android',
+        value: await _failSafeSpawn('avdmanager', ['list', 'target'])
+    }]
+};
+
+const _failSafeSpawn = (command, args) => execa(command, args).then(
+    ({ stdout }) => stdout,
+    err => `ERROR: ${err.message}`
+);
+
+function _formatNodeList (list, level = 0) {
+    const content = [];
+
+    for (const item of list) {
+        const indent = String.prototype.padStart((4 * level), ' ');
+        let itemString = `${indent}${item.key}:`;
+
+        if ('value' in item) {
+            // Pad multi-line values with a new line on either end
+            itemString += (/[\r\n]/.test(item.value))
+                ? `\n${item.value.trim()}\n`
+                : ` ${item.value}`;
+        } else {
+            // Start of section
+            itemString = `\n${itemString}\n`;
+        }
+
+        content.push(itemString);
+
+        if (item.children) {
+            content.push(..._formatNodeList(item.children, level + 1));
+        }
+    }
+
+    return content;
+}
+
+module.exports = async function () {
+    const projectRoot = cdvLibUtil.cdProjectRoot();
+
+    const results = await Promise.all([
+        getCordovaDependenciesInfo(),
+        getInstalledPlatforms(projectRoot),
+        getInstalledPlugins(projectRoot),
+        getEnvironmentInfo(),
+        ...(await getPlatformEnvironmentData(projectRoot)),
+        getProjectSettingsFiles(projectRoot)
+    ]);
+
+    const content = _formatNodeList(results);
+    cordova.emit('results', content.join('\n'));
+};

spa/node_modules/cordova/src/telemetry.js

@@ -0,0 +1,129 @@
+/**
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+*/
+
+// For further details on telemetry, see:
+// https://github.com/cordova/cordova-discuss/pull/43
+
+const { EOL } = require('os');
+
+// Google Analytics tracking code
+const GA_TRACKING_CODE = 'UA-64283057-7';
+
+const pkg = require('../package.json');
+const Insight = require('insight');
+
+/**
+ * By redefining `get optOut` we trick Insight into tracking
+ * even though the user might have opted out.
+ */
+class RelentlessInsight extends Insight {
+    get optOut () { return false; }
+
+    set optOut (value) { super.optOut = value; }
+
+    get realOptOut () { return super.optOut; }
+}
+
+const insight = new RelentlessInsight({
+    trackingCode: GA_TRACKING_CODE,
+    pkg
+});
+
+/**
+ * Returns true if the user opted in, and false otherwise
+ */
+function showPrompt () {
+    insight._permissionTimeout = module.exports.timeoutInSecs || 30;
+
+    const msg = 'May Cordova anonymously report usage statistics to improve the tool over time?';
+
+    return insight.askPermission(msg).then(optIn => {
+        if (optIn) {
+            console.log(EOL + 'Thanks for opting into telemetry to help us improve cordova.');
+            module.exports.track('telemetry', 'on', 'via-cli-prompt-choice', 'successful');
+        } else {
+            console.log(EOL + 'You have been opted out of telemetry. To change this, run: cordova telemetry on.');
+            // Always track telemetry opt-outs! (whether opted-in or opted-out)
+            module.exports.track('telemetry', 'off', 'via-cli-prompt-choice', 'successful');
+        }
+
+        return optIn;
+    });
+}
+
+function track (...args) {
+    // Remove empty, null or undefined strings from arguments
+    const filteredArgs = args.filter(val => val && val.length !== 0);
+    insight.track(...filteredArgs);
+}
+
+function turnOn () {
+    insight.optOut = false;
+}
+
+function turnOff () {
+    insight.optOut = true;
+}
+
+/**
+ * Clears telemetry setting
+ * Has the same effect as if user never answered the telemetry prompt
+ * Useful for testing purposes
+ */
+function clear () {
+    insight.optOut = undefined;
+}
+
+function isOptedIn () {
+    return !insight.realOptOut;
+}
+
+/**
+ * Has the user already answered the telemetry prompt? (thereby opting in or out?)
+ */
+function hasUserOptedInOrOut () {
+    const insightOptOut = insight.realOptOut === undefined;
+    return !(insightOptOut);
+}
+
+/**
+ * Is the environment variable 'CI' specified ?
+ */
+function isCI (env) {
+    return !!env.CI;
+}
+
+/**
+ * Has the user ran a command of the form: `cordova run --no-telemetry` ?
+ */
+function isNoTelemetryFlag (args) {
+    return args.indexOf('--no-telemetry') > -1;
+}
+
+// this is to help testing, so we don't have to wait for the full 30
+module.exports = {
+    track,
+    turnOn,
+    turnOff,
+    clear,
+    isOptedIn,
+    hasUserOptedInOrOut,
+    isCI,
+    showPrompt,
+    isNoTelemetryFlag,
+    timeoutInSecs: 30
+};