Channel stuff added

ionic.config.json

@@ -1,8 +1,8 @@
 {
   "name": "zipteamUIv2",
-  "app_id": "",
-  "type": "ionic-angular",
   "integrations": {
     "cordova": {}
-  }
+  },
+  "type": "ionic-angular",
+  "app_id": ""
 }

node_modules/.bin/ncp

@@ -0,0 +1 @@
+../ncp/bin/ncp

node_modules/@ionic/cli-plugin-ionic-angular/CHANGELOG.md

@@ -0,0 +1,90 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="1.4.1"></a>
+## [1.4.1](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.4.0...@ionic/cli-plugin-ionic-angular@1.4.1) (2017-08-03)
+
+
+### Bug Fixes
+
+* **serve:** allow binding of localhost ([e8a74d0](https://github.com/ionic-team/ionic-cli/commit/e8a74d0))
+
+
+
+
+<a name="1.4.0"></a>
+# [1.4.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.3.2...@ionic/cli-plugin-ionic-angular@1.4.0) (2017-07-27)
+
+
+### Features
+
+* ionic pro ([36dc2f7](https://github.com/ionic-team/ionic-cli/commit/36dc2f7))
+* **generators:** add fall back for old app-scripts ([d41a4b5](https://github.com/ionic-team/ionic-cli/commit/d41a4b5))
+* **generators:** add fall back for old app-scripts ([33097e7](https://github.com/ionic-team/ionic-cli/commit/33097e7))
+* **generators:** add module options ([6c85a8e](https://github.com/ionic-team/ionic-cli/commit/6c85a8e))
+* **generators:** add option for creating a constants file ([db7b983](https://github.com/ionic-team/ionic-cli/commit/db7b983))
+* **generators:** pass all the options ([6401822](https://github.com/ionic-team/ionic-cli/commit/6401822))
+
+
+
+
+<a name="1.3.2"></a>
+## [1.3.2](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.3.1...@ionic/cli-plugin-ionic-angular@1.3.2) (2017-07-11)
+
+
+
+
+<a name="1.3.1"></a>
+## [1.3.1](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.3.0...@ionic/cli-plugin-ionic-angular@1.3.1) (2017-06-12)
+
+
+### Bug Fixes
+
+* **serve:** 0.0.0.0, but open localhost in local browser ([e337813](https://github.com/ionic-team/ionic-cli/commit/e337813))
+
+
+
+
+<a name="1.3.0"></a>
+# [1.3.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.2.0...@ionic/cli-plugin-ionic-angular@1.3.0) (2017-05-31)
+
+
+### Bug Fixes
+
+* **cordova:** fix arg parser ([94db925](https://github.com/ionic-team/ionic-cli/commit/94db925))
+
+
+
+
+<a name="1.2.0"></a>
+# [1.2.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.1.2...@ionic/cli-plugin-ionic-angular@1.2.0) (2017-05-23)
+
+
+### Features
+
+* **flags:** --no-interactive mode, with --confirm/--no-confirm ([1966a0c](https://github.com/ionic-team/ionic-cli/commit/1966a0c))
+
+
+
+
+<a name="1.1.2"></a>
+## [1.1.2](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.1.1...@ionic/cli-plugin-ionic-angular@1.1.2) (2017-05-17)
+
+
+
+
+<a name="1.1.1"></a>
+## [1.1.1](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.1.0...@ionic/cli-plugin-ionic-angular@1.1.1) (2017-05-16)
+
+
+### Bug Fixes
+
+* **plugins:** messaging about globally installed plugins ([def3891](https://github.com/ionic-team/ionic-cli/commit/def3891))
+
+
+
+
+<a name="1.1.0"></a>
+# [1.1.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-plugin-ionic-angular@1.0.0...@ionic/cli-plugin-ionic-angular@1.1.0) (2017-05-16)

node_modules/@ionic/cli-plugin-ionic-angular/README.md

@@ -0,0 +1,3 @@
+# @ionic/cli-plugin-ionic-angular
+
+This CLI project plugin provides Ionic Angular functionality to the CLI.

node_modules/@ionic/cli-plugin-ionic-angular/dist/build.d.ts

@@ -0,0 +1,2 @@
+import { CommandHookArgs } from '@ionic/cli-utils';
+export declare function build(args: CommandHookArgs): Promise<void>;

node_modules/@ionic/cli-plugin-ionic-angular/dist/build.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const cli_utils_1 = require("@ionic/cli-utils");
+const modules_1 = require("./lib/modules");
+function build(args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const appScriptsArgs = cli_utils_1.minimistOptionsToArray(args.options, { useEquals: false, ignoreFalse: true, allowCamelCase: true });
+        process.argv = ['node', 'appscripts'].concat(appScriptsArgs);
+        const AppScripts = modules_1.load('@ionic/app-scripts');
+        const context = AppScripts.generateContext();
+        console.log(`Running app-scripts build: ${chalk.bold(appScriptsArgs.join(' '))}\n`);
+        return yield AppScripts.build(context);
+    });
+}
+exports.build = build;

node_modules/@ionic/cli-plugin-ionic-angular/dist/generate.d.ts

@@ -0,0 +1,2 @@
+import { CommandHookArgs } from '@ionic/cli-utils';
+export declare function generate(args: CommandHookArgs): Promise<string[]>;

node_modules/@ionic/cli-plugin-ionic-angular/dist/generate.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const path = require("path");
+const cli_utils_1 = require("@ionic/cli-utils");
+const modules_1 = require("./lib/modules");
+const generate_1 = require("./utils/generate");
+function generate(args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!args.env.project.directory) {
+            return [];
+        }
+        const appScriptsArgs = cli_utils_1.minimistOptionsToArray(args.options, { useEquals: false, ignoreFalse: true, allowCamelCase: true });
+        process.argv = ['node', 'appscripts'].concat(appScriptsArgs);
+        const ionicAngularPackageJsonFilePath = path.resolve(args.env.project.directory, 'node_modules', 'ionic-angular', 'package.json'); // TODO
+        try {
+            const ionicAngularPackageJson = yield cli_utils_1.readPackageJsonFile(ionicAngularPackageJsonFilePath);
+            if (ionicAngularPackageJson.version && Number(ionicAngularPackageJson.version.charAt(0)) < 3) {
+                throw new Error(`The generate command is only available for projects that use ionic-angular >= 3.0.0`);
+            }
+        }
+        catch (e) {
+            args.env.log.error(`Error with ${chalk.bold(cli_utils_1.prettyPath(ionicAngularPackageJsonFilePath))} file: ${e}`);
+        }
+        const AppScripts = modules_1.load('@ionic/app-scripts');
+        const context = AppScripts.generateContext();
+        const [type, name] = args.inputs;
+        const commandOptions = {
+            module: false,
+            constants: false,
+        };
+        if (args.options['module']) {
+            commandOptions.module = true;
+        }
+        if (args.options['constants']) {
+            commandOptions.constants = true;
+        }
+        switch (type) {
+            case 'page':
+                yield AppScripts.processPageRequest(context, name, commandOptions);
+                break;
+            case 'component':
+                const componentData = yield generate_1.getModules(context, 'component');
+                yield AppScripts.processComponentRequest(context, name, componentData);
+                break;
+            case 'directive':
+                const directiveData = yield generate_1.getModules(context, 'directive');
+                yield AppScripts.processDirectiveRequest(context, name, directiveData);
+                break;
+            case 'pipe':
+                const pipeData = yield generate_1.getModules(context, 'pipe');
+                yield AppScripts.processPipeRequest(context, name, pipeData);
+                break;
+            case 'provider':
+                const providerData = yield promptQuestions(context);
+                yield AppScripts.processProviderRequest(context, name, providerData);
+                break;
+            case 'tabs':
+                const tabsData = yield generate_1.tabsPrompt(args.env);
+                yield AppScripts.processTabsRequest(context, name, tabsData, commandOptions);
+                break;
+        }
+        return [];
+    });
+}
+exports.generate = generate;
+function promptQuestions(context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield generate_1.prompt(context);
+    });
+}

node_modules/@ionic/cli-plugin-ionic-angular/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { IHookEngine } from '@ionic/cli-utils';
+export declare const name = "__NAME__";
+export declare const version = "__VERSION__";
+export declare function registerHooks(hooks: IHookEngine): void;

node_modules/@ionic/cli-plugin-ionic-angular/dist/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const path = require("path");
+const cli_utils_1 = require("@ionic/cli-utils");
+const build_1 = require("./build");
+const generate_1 = require("./generate");
+const serve_1 = require("./serve");
+exports.name = '@ionic/cli-plugin-ionic-angular';
+exports.version = '1.4.1';
+function getIonicAngularVersion(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const ionicAngularPackageJsonFilePath = path.resolve(env.project.directory, 'node_modules', 'ionic-angular', 'package.json'); // TODO
+        try {
+            const ionicAngularPackageJson = yield cli_utils_1.readPackageJsonFile(ionicAngularPackageJsonFilePath);
+            return ionicAngularPackageJson.version;
+        }
+        catch (e) {
+            env.log.error(`Error with ${chalk.bold(cli_utils_1.prettyPath(ionicAngularPackageJsonFilePath))} file: ${e}`);
+        }
+    });
+}
+function getAppScriptsVersion(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const appScriptsPackageJsonFilePath = path.resolve(env.project.directory, 'node_modules', '@ionic', 'app-scripts', 'package.json'); // TODO
+        try {
+            const appScriptsPackageJson = yield cli_utils_1.readPackageJsonFile(appScriptsPackageJsonFilePath);
+            return appScriptsPackageJson.version;
+        }
+        catch (e) {
+            env.log.error(`Error with ${chalk.bold(cli_utils_1.prettyPath(appScriptsPackageJsonFilePath))} file: ${e}`);
+        }
+    });
+}
+function registerHooks(hooks) {
+    hooks.register(exports.name, 'command:docs', ({ env }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const docsHomepage = 'https://ionicframework.com/docs';
+        if (!env.project.directory) {
+            return docsHomepage;
+        }
+        const ionicAngularVersion = yield getIonicAngularVersion(env);
+        const url = `${docsHomepage}/${ionicAngularVersion ? ionicAngularVersion + '/' : ''}api`;
+        return url;
+    }));
+    hooks.register(exports.name, 'command:generate', (args) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield generate_1.generate(args);
+    }));
+    hooks.register(exports.name, 'command:info', ({ env }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!env.project.directory) {
+            return [];
+        }
+        const [ionicAngularVersion, appScriptsVersion] = yield Promise.all([getIonicAngularVersion(env), getAppScriptsVersion(env)]);
+        return [
+            { type: 'local-packages', name: 'Ionic Framework', version: ionicAngularVersion ? `ionic-angular ${ionicAngularVersion}` : 'not installed' },
+            { type: 'cli-packages', name: exports.name, version: exports.version, path: path.dirname(path.dirname(__filename)) },
+            { type: 'local-packages', name: '@ionic/app-scripts', version: appScriptsVersion ? appScriptsVersion : 'not installed' },
+        ];
+    }));
+    hooks.register(exports.name, 'command:serve', (args) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return serve_1.serve(args);
+    }));
+    hooks.register(exports.name, 'command:build', (args) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield build_1.build(args);
+    }));
+}
+exports.registerHooks = registerHooks;

node_modules/@ionic/cli-plugin-ionic-angular/dist/lib/modules.d.ts

@@ -0,0 +1,2 @@
+import * as AppScriptsType from '@ionic/app-scripts';
+export declare function load(modulePath: '@ionic/app-scripts'): typeof AppScriptsType;

node_modules/@ionic/cli-plugin-ionic-angular/dist/lib/modules.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function load(modulePath) {
+    return require(modulePath);
+}
+exports.load = load;

node_modules/@ionic/cli-plugin-ionic-angular/dist/serve.d.ts

@@ -0,0 +1,2 @@
+import { CommandHookArgs, ServeCommandHookResponse } from '@ionic/cli-utils';
+export declare function serve(args: CommandHookArgs): Promise<ServeCommandHookResponse>;

node_modules/@ionic/cli-plugin-ionic-angular/dist/serve.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const cli_utils_1 = require("@ionic/cli-utils");
+const modules_1 = require("./lib/modules");
+function serve(args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const address = args.options['address'] || '0.0.0.0';
+        const locallyAccessible = ['0.0.0.0', 'localhost', '127.0.0.1'].includes(address);
+        let externalIP = address;
+        if (address === '0.0.0.0') {
+            const availableIPs = cli_utils_1.getAvailableIPAddress();
+            if (availableIPs.length === 0) {
+                throw new Error(`It appears that you do not have any external network interfaces. ` +
+                    `In order to use livereload with emulate you will need one.`);
+            }
+            externalIP = availableIPs[0].address;
+            if (availableIPs.length > 1) {
+                if (availableIPs.find(({ address }) => address === args.options.address)) {
+                    externalIP = args.options.address;
+                }
+                else {
+                    args.env.log.warn(`${chalk.bold('Multiple network interfaces detected!')}\n` +
+                        'You will be prompted to select an external-facing IP for the livereload server that your device or emulator has access to.\n' +
+                        `You may also use the ${chalk.green('--address')} option to skip this prompt.\n`);
+                    const promptedIp = yield args.env.prompt({
+                        type: 'list',
+                        name: 'promptedIp',
+                        message: 'Please select which IP to use:',
+                        choices: availableIPs.map(ip => ip.address)
+                    });
+                    externalIP = promptedIp;
+                }
+            }
+        }
+        const appScriptsArgs = cli_utils_1.minimistOptionsToArray(args.options, { useEquals: false, ignoreFalse: true, allowCamelCase: true });
+        process.argv = ['node', 'appscripts'].concat(appScriptsArgs);
+        const AppScripts = modules_1.load('@ionic/app-scripts');
+        const context = AppScripts.generateContext();
+        // using app-scripts and livereload is requested
+        // Also remove commandName from the rawArgs passed
+        args.env.log.info(`Starting app-scripts server: ${chalk.bold(appScriptsArgs.join(' '))} - Ctrl+C to cancel`);
+        const settings = yield AppScripts.serve(context);
+        if (!settings) {
+            throw new cli_utils_1.FatalException(`app-scripts serve unexpectedly failed.` +
+                `settings: ${settings}` +
+                `context: ${context}`);
+        }
+        const localAddress = 'http://localhost:' + settings.httpPort;
+        const externalAddress = 'http://' + externalIP + ':' + settings.httpPort;
+        const externallyAccessible = localAddress !== externalAddress;
+        args.env.log.info(`Development server running\n` +
+            (locallyAccessible ? `Local: ${chalk.bold(localAddress)}\n` : '') +
+            (externallyAccessible ? `External: ${chalk.bold(externalAddress)}` : ''));
+        return Object.assign({ publicIp: externalIP, protocol: 'http', localAddress: 'localhost', externalAddress: externalIP, port: settings.httpPort, locallyAccessible,
+            externallyAccessible }, settings);
+    });
+}
+exports.serve = serve;

node_modules/@ionic/cli-plugin-ionic-angular/dist/utils/generate.d.ts

@@ -0,0 +1,10 @@
+import { IonicEnvironment } from '@ionic/cli-utils';
+import * as AppScriptsType from '@ionic/app-scripts';
+export declare function getPages(context: AppScriptsType.BuildContext): Promise<{
+    fileName: string;
+    absolutePath: string;
+    relativePath: string;
+}[]>;
+export declare function prompt(context: AppScriptsType.BuildContext): Promise<string>;
+export declare function getModules(context: AppScriptsType.BuildContext, kind: string): Promise<string>;
+export declare function tabsPrompt(env: IonicEnvironment): Promise<string[]>;

node_modules/@ionic/cli-plugin-ionic-angular/dist/utils/generate.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = require("path");
+const cli_utils_1 = require("@ionic/cli-utils");
+const modules_1 = require("../lib/modules");
+function getPages(context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const AppScripts = modules_1.load('@ionic/app-scripts');
+        const pages = yield AppScripts.getNgModules(context, ['page', 'component']);
+        const ngModuleSuffix = yield AppScripts.getStringPropertyValue('IONIC_NG_MODULE_FILENAME_SUFFIX');
+        return pages.map((page) => {
+            return {
+                fileName: path.basename(page.absolutePath, ngModuleSuffix),
+                absolutePath: page.absolutePath,
+                relativePath: path.relative(context.rootDir, page.absolutePath)
+            };
+        });
+    });
+}
+exports.getPages = getPages;
+function prompt(context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return context.appNgModulePath;
+    });
+}
+exports.prompt = prompt;
+function getModules(context, kind) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        switch (kind) {
+            case 'component':
+                return context.componentsNgModulePath ? context.componentsNgModulePath : context.appNgModulePath;
+            case 'pipe':
+                return context.pipesNgModulePath ? context.pipesNgModulePath : context.appNgModulePath;
+            case 'directive':
+                return context.directivesNgModulePath ? context.directivesNgModulePath : context.appNgModulePath;
+        }
+    });
+}
+exports.getModules = getModules;
+function tabsPrompt(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const tabNames = [];
+        const howMany = yield env.prompt({
+            type: 'input',
+            name: 'howMany',
+            message: 'How many tabs?',
+            validate: v => cli_utils_1.validators.numeric(v),
+        });
+        for (let i = 0; i < parseInt(howMany, 10); i++) {
+            const tabName = yield env.prompt({
+                type: 'input',
+                name: 'tabName',
+                message: 'Name of this tab:'
+            });
+            tabNames.push(tabName);
+        }
+        return tabNames;
+    });
+}
+exports.tabsPrompt = tabsPrompt;

node_modules/@ionic/cli-plugin-ionic-angular/package.json

@@ -0,0 +1,90 @@
+{
+  "_from": "@ionic/cli-plugin-ionic-angular@latest",
+  "_id": "@ionic/cli-plugin-ionic-angular@1.4.1",
+  "_inBundle": false,
+  "_integrity": "sha512-GwGbDH+n6Qajw8faZBD3qq9xh4+DTBdwQqf6EpI4/DkHfzWzeq6asvRjrY1TPTDfMinQI5NTsrx0zup4qceGFA==",
+  "_location": "/@ionic/cli-plugin-ionic-angular",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "@ionic/cli-plugin-ionic-angular@latest",
+    "name": "@ionic/cli-plugin-ionic-angular",
+    "escapedName": "@ionic%2fcli-plugin-ionic-angular",
+    "scope": "@ionic",
+    "rawSpec": "latest",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#DEV:/",
+    "#USER"
+  ],
+  "_resolved": "https://registry.npmjs.org/@ionic/cli-plugin-ionic-angular/-/cli-plugin-ionic-angular-1.4.1.tgz",
+  "_shasum": "bb94b7ad61c2f79757b2dff041c0b7e2151777ec",
+  "_spec": "@ionic/cli-plugin-ionic-angular@latest",
+  "_where": "/Users/nicholasm/Labs/ZipTeamPurple-FrontEnd",
+  "author": {
+    "name": "Ionic Team",
+    "email": "hi@ionic.io",
+    "url": "http://ionic.io"
+  },
+  "bugs": {
+    "url": "https://github.com/ionic-team/ionic-cli/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@ionic/cli-utils": "1.7.0",
+    "chalk": "^2.0.0",
+    "tslib": "^1.7.1"
+  },
+  "deprecated": "latest Ionic CLI no longer uses this plugin",
+  "description": "Ionic CLI build plugin for Ionic Angular projects",
+  "devDependencies": {
+    "@angular/compiler": "^4.3.2",
+    "@angular/compiler-cli": "^4.3.2",
+    "@angular/core": "^4.3.2",
+    "@ionic/app-scripts": "^2.1.0",
+    "@ionic/cli-scripts": "0.3.1",
+    "@types/chalk": "^0.4.31",
+    "@types/clean-css": "^3.4.30",
+    "rxjs": "^5.4.1"
+  },
+  "files": [
+    "dist/"
+  ],
+  "homepage": "https://ionic.io/",
+  "jest": {
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "transform": {
+      ".(ts)": "<rootDir>/../../node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "/__tests__/.*\\.(ts|js)$",
+    "setupFiles": []
+  },
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "name": "@ionic/cli-plugin-ionic-angular",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ionic-team/ionic-cli.git"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run build-ts && npm run build-js",
+    "build-js": "npm run script-prepublish",
+    "build-ts": "tsc",
+    "clean": "rm -rf ./dist",
+    "lint": "tslint --config ../../tslint.js --project tsconfig.json --type-check",
+    "prepublish": "npm run build",
+    "script-prepublish": "cli-scripts-prepublish cli-plugin-ionic-angular",
+    "test": "jest",
+    "watch": "concurrently -p \"{name} \" -n \"TS,JS\" -c \"cyan.bold,yellow.dim\" \"npm run watch-ts\" \"npm run watch-js\"",
+    "watch-js": "cross-env-shell IONIC_PREPUBLISH_PLUGIN_VERSION=${npm_package_version}-local \"npm run watch-js-chokidar\"",
+    "watch-js-chokidar": "chokidar --silent \"dist/**/*.js\" -c \"npm run build-js\"",
+    "watch-ts": "tsc -w"
+  },
+  "version": "1.4.1"
+}

node_modules/@ionic/cli-utils/.npmignore

@@ -0,0 +1,2 @@
+src
+tsconfig.json

node_modules/@ionic/cli-utils/CHANGELOG.md

@@ -0,0 +1,146 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="1.7.0"></a>
+# [1.7.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.6.0...@ionic/cli-utils@1.7.0) (2017-08-03)
+
+
+### Bug Fixes
+
+* **daemon:** fix occasional ENOENT error on windows ([1beb455](https://github.com/ionic-team/ionic-cli/commit/1beb455))
+* **help:** "undefined" slipped in to some help output ([1f885fa](https://github.com/ionic-team/ionic-cli/commit/1f885fa))
+* **plugins:** small fix for differing dist tags of plugins ([3adfcb6](https://github.com/ionic-team/ionic-cli/commit/3adfcb6))
+* **serve:** allow binding of localhost ([e8a74d0](https://github.com/ionic-team/ionic-cli/commit/e8a74d0))
+* **start:** disable yarn dedupe during start ([dd5c35f](https://github.com/ionic-team/ionic-cli/commit/dd5c35f))
+
+
+### Features
+
+* **build:** `ionic build` command ([3ad304c](https://github.com/ionic-team/ionic-cli/commit/3ad304c))
+
+
+
+
+<a name="1.6.0"></a>
+# [1.6.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.5.0...@ionic/cli-utils@1.6.0) (2017-07-27)
+
+
+### Bug Fixes
+
+* **timeouts:** rip out timeouts ([22dcd2f](https://github.com/ionic-team/ionic-cli/commit/22dcd2f))
+
+
+### Features
+
+* ionic pro ([36dc2f7](https://github.com/ionic-team/ionic-cli/commit/36dc2f7))
+
+
+
+
+<a name="1.5.0"></a>
+# [1.5.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.4.0...@ionic/cli-utils@1.5.0) (2017-07-11)
+
+
+### Bug Fixes
+
+* better icon support for windows ([47ea9ab](https://github.com/ionic-team/ionic-cli/commit/47ea9ab))
+* **link:** disable interpretation of scientific notation ([3874ca6](https://github.com/ionic-team/ionic-cli/commit/3874ca6))
+* **project:** warn users of ionic.project file ([965af07](https://github.com/ionic-team/ionic-cli/commit/965af07))
+* **start:** substitute invalid package.json name for MyApp ([ce6c129](https://github.com/ionic-team/ionic-cli/commit/ce6c129))
+
+
+### Features
+
+* **cloud:** add options for snapshot metadata ([75099e6](https://github.com/ionic-team/ionic-cli/commit/75099e6))
+
+
+
+
+<a name="1.4.0"></a>
+# [1.4.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.3.0...@ionic/cli-utils@1.4.0) (2017-06-12)
+
+
+### Bug Fixes
+
+* **cordova:** actually show platform/type of missing resources ([4e154ed](https://github.com/ionic-team/ionic-cli/commit/4e154ed))
+* **ionic1:** logger not logging changed files ([1b51529](https://github.com/ionic-team/ionic-cli/commit/1b51529))
+* **plugins:** catch npm errors during updates and continue ([316826d](https://github.com/ionic-team/ionic-cli/commit/316826d))
+* **serve:** running ionic serve in background ([883c21e](https://github.com/ionic-team/ionic-cli/commit/883c21e))
+
+
+### Features
+
+* **hooks:** call npm script hooks ([e34fc34](https://github.com/ionic-team/ionic-cli/commit/e34fc34))
+* **plugins:** warn about multiple installed project plugins ([88789d8](https://github.com/ionic-team/ionic-cli/commit/88789d8))
+
+
+
+
+<a name="1.3.0"></a>
+# [1.3.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.2.0...@ionic/cli-utils@1.3.0) (2017-05-31)
+
+
+### Bug Fixes
+
+* **cordova:** more arg parsing fixes... ([4a75255](https://github.com/ionic-team/ionic-cli/commit/4a75255))
+* **proxy:** use env load to ensure shared reference ([8552826](https://github.com/ionic-team/ionic-cli/commit/8552826))
+
+
+
+
+<a name="1.2.0"></a>
+# [1.2.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.1.2...@ionic/cli-utils@1.2.0) (2017-05-23)
+
+
+### Bug Fixes
+
+* **cli-plugin-ionic1:** use documentRoot and watchPatterns from ionic.config.json ([a878a95](https://github.com/ionic-team/ionic-cli/commit/a878a95))
+* don't swallow subprocess stdout during --verbose ([d53d11a](https://github.com/ionic-team/ionic-cli/commit/d53d11a))
+* **config:** Handle empty file ([fbcfc76](https://github.com/ionic-team/ionic-cli/commit/fbcfc76))
+* **package:** dates not internationalized, use ISO ([0674bd9](https://github.com/ionic-team/ionic-cli/commit/0674bd9))
+
+
+### Features
+
+* **flags:** --no-interactive mode, with --confirm/--no-confirm ([1966a0c](https://github.com/ionic-team/ionic-cli/commit/1966a0c))
+* **flags:** add --quiet flag ([6268f0c](https://github.com/ionic-team/ionic-cli/commit/6268f0c))
+* **flags:** persistent "cli flags" ([72a9b45](https://github.com/ionic-team/ionic-cli/commit/72a9b45))
+* **logging:** disable interval spinner for non-interactive mode ([9e4ed33](https://github.com/ionic-team/ionic-cli/commit/9e4ed33))
+* **login:** automatic login via IONIC_EMAIL/IONIC_PASSWORD ([d8d26e4](https://github.com/ionic-team/ionic-cli/commit/d8d26e4))
+
+
+
+
+<a name="1.1.2"></a>
+## [1.1.2](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.1.1...@ionic/cli-utils@1.1.2) (2017-05-17)
+
+
+
+
+<a name="1.1.1"></a>
+## [1.1.1](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.1.0...@ionic/cli-utils@1.1.1) (2017-05-16)
+
+
+### Bug Fixes
+
+* **plugins:** messaging about globally installed plugins ([def3891](https://github.com/ionic-team/ionic-cli/commit/def3891))
+
+
+
+
+<a name="1.1.0"></a>
+# [1.1.0](https://github.com/ionic-team/ionic-cli/compare/@ionic/cli-utils@1.0.0...@ionic/cli-utils@1.1.0) (2017-05-16)
+
+
+### Bug Fixes
+
+* prevent TypeError runtime error ([1283f49](https://github.com/ionic-team/ionic-cli/commit/1283f49))
+* **cordova:** give cordova options after -- separator (https://github.com/ionic-team/ionic-cli/issues/2254) ([256503e](https://github.com/ionic-team/ionic-cli/commit/256503e))
+* **upload:** rip out progress library (fixes https://github.com/ionic-team/ionic-cli/issues/2257) ([1559049](https://github.com/ionic-team/ionic-cli/commit/1559049))
+
+
+### Features
+
+* **proxy:** global proxy plugin for start/login ([be89cb1](https://github.com/ionic-team/ionic-cli/commit/be89cb1))

node_modules/@ionic/cli-utils/README.md

@@ -0,0 +1 @@
+# `@ionic/cli-utils`

node_modules/@ionic/cli-utils/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function detectLocalCLI(): Promise<string | undefined>;

node_modules/@ionic/cli-utils/bootstrap.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = require("fs");
+const path = require("path");
+const fs_1 = require("./lib/utils/fs");
+function detectLocalCLI() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const dir = yield fs_1.findBaseDirectory(process.cwd(), 'package.json');
+        if (dir) {
+            const local = path.join(dir, 'node_modules', 'ionic');
+            const ok = yield fs_1.pathAccessible(local, fs.constants.R_OK);
+            if (ok) {
+                return local;
+            }
+        }
+    });
+}
+exports.detectLocalCLI = detectLocalCLI;

node_modules/@ionic/cli-utils/definitions.d.ts

@@ -0,0 +1,556 @@
+/// <reference types="node" />
+import * as crossSpawnType from 'cross-spawn';
+import * as inquirerType from 'inquirer';
+import * as semverType from 'semver';
+import * as superagentType from 'superagent';
+import * as lodashType from 'lodash';
+import * as minimistType from 'minimist';
+import { EventEmitter } from 'events';
+export interface SuperAgentError extends Error {
+    response: superagentType.Response;
+}
+export declare type LogFn = (msg: string | (() => string)) => void;
+export declare type LogLevel = 'debug' | 'info' | 'ok' | 'warn' | 'error';
+export interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string | (() => string);
+    stream?: NodeJS.WritableStream;
+}
+export interface ILogger {
+    level: LogLevel;
+    prefix: string | (() => string);
+    stream: NodeJS.WritableStream;
+    debug: LogFn;
+    info: LogFn;
+    ok: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    msg: LogFn;
+    nl(num?: number): void;
+    shouldLog(level: LogLevel): boolean;
+}
+export interface ITask {
+    msg: string;
+    running: boolean;
+    progressRatio: number;
+    start(): this;
+    progress(prog: number, total: number): this;
+    clear(): this;
+    succeed(): this;
+    fail(): this;
+    end(): this;
+}
+export interface ITaskChain {
+    next(msg: string): ITask;
+    updateMsg(msg: string): this;
+    end(): this;
+    fail(): this;
+    cleanup(): this;
+}
+export interface PackageJson {
+    name: string;
+    version?: string;
+    scripts?: {
+        [key: string]: string;
+    };
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
+        [key: string]: string;
+    };
+    peerDependencies?: {
+        [key: string]: string;
+    };
+}
+export interface BowerJson {
+    name: string;
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
+        [key: string]: string;
+    };
+}
+export interface ProjectFileProxy {
+    proxyUrl: string;
+    proxyNoAgent: boolean;
+    rejectUnauthorized: boolean;
+    path: string;
+}
+export declare type ProjectType = 'ionic-angular' | 'ionic1';
+export interface ProjectFile {
+    name: string;
+    type: ProjectType;
+    app_id: string;
+    gulpFile?: string;
+    documentRoot?: string;
+    watchPatterns?: string[];
+    proxies?: ProjectFileProxy[];
+}
+export interface Response<T> extends APIResponseSuccess {
+    data: T;
+}
+export interface AppDetails {
+    id: string;
+    name: string;
+    slug: string;
+    repo_url?: string;
+}
+export interface AuthToken {
+    token: string;
+    details: {
+        app_id: string;
+        type: 'app-user';
+        user_id: string;
+    };
+}
+export interface SSHKey {
+    id: string;
+    pubkey: string;
+    fingerprint: string;
+    annotation: string;
+    name: string;
+    created: string;
+    updated: string;
+}
+export interface DeploySnapshot {
+    uuid: string;
+    url: string;
+}
+export interface DeploySnapshotRequest extends DeploySnapshot {
+    presigned_post: {
+        url: string;
+        fields: Object;
+    };
+}
+export interface DeployChannel {
+    uuid: string;
+    tag: string;
+}
+export interface Deploy {
+    uuid: string;
+    snapshot: string;
+    channel: string;
+}
+export interface PackageProjectRequest {
+    id: number;
+    presigned_post: {
+        url: string;
+        fields: Object;
+    };
+}
+export interface PackageBuild {
+    id: number;
+    name: string | null;
+    created: string;
+    completed: string | null;
+    platform: 'android' | 'ios';
+    status: 'SUCCESS' | 'FAILED' | 'QUEUED' | 'BUILDING';
+    mode: 'debug' | 'release';
+    security_profile_tag: string | null;
+    url?: string | null;
+    output?: string | null;
+}
+export interface SecurityProfile {
+    name: string;
+    tag: string;
+    type: 'development' | 'production';
+    created: string;
+    credentials: {
+        android?: Object;
+        ios?: Object;
+    };
+}
+export interface IApp {
+    load(app_id?: string): Promise<AppDetails>;
+}
+export interface IProject extends IConfig<ProjectFile> {
+    directory: string;
+    formatType(input: ProjectType): string;
+    loadAppId(): Promise<string>;
+    loadPackageJson(): Promise<PackageJson>;
+    loadBowerJson(): Promise<BowerJson>;
+}
+export interface PackageVersions {
+    [key: string]: string;
+}
+export interface DaemonFile {
+    daemonVersion: string;
+    latestVersions: {
+        latest: PackageVersions;
+        [key: string]: PackageVersions;
+    };
+}
+export interface IDaemon extends IConfig<DaemonFile> {
+    pidFilePath: string;
+    logFilePath: string;
+    getPid(): Promise<number | undefined>;
+    setPid(pid: number): Promise<void>;
+    populateDistTag(distTag: DistTag): void;
+}
+export declare type CommandLineInput = string | boolean | null | undefined | string[];
+export declare type CommandLineInputs = string[];
+export interface CommandLineOptions extends minimistType.ParsedArgs {
+    [arg: string]: CommandLineInput;
+}
+export declare type CommandOptionType = StringConstructor | BooleanConstructor;
+export declare type CommandOptionTypeDefaults = Map<CommandOptionType, CommandLineInput>;
+export interface CommandOption {
+    name: string;
+    description: string;
+    backends?: BackendFlag[];
+    type?: CommandOptionType;
+    default?: CommandLineInput;
+    aliases?: string[];
+    private?: boolean;
+    intent?: string;
+    visible?: boolean;
+}
+export interface NormalizedCommandOption extends CommandOption {
+    type: CommandOptionType;
+    default: CommandLineInput;
+    aliases: string[];
+}
+export interface ExitCodeException extends Error {
+    exitCode: number;
+}
+export declare type Validator = (input?: string, key?: string) => true | string;
+export interface Validators {
+    required: Validator;
+    email: Validator;
+    numeric: Validator;
+}
+export interface ValidationError {
+    message: string;
+    inputName: string;
+}
+export interface CommandInput {
+    name: string;
+    description: string;
+    validators?: Validator[];
+    required?: boolean;
+    private?: boolean;
+}
+export interface NormalizedMinimistOpts extends minimistType.Opts {
+    string: string[];
+    boolean: string[];
+    alias: {
+        [key: string]: string[];
+    };
+    default: {
+        [key: string]: CommandLineInput;
+    };
+}
+export declare type BackendFlag = 'pro' | 'legacy';
+export interface CommandData {
+    name: string;
+    type: 'global' | 'project';
+    backends?: BackendFlag[];
+    description: string;
+    longDescription?: string;
+    exampleCommands?: string[];
+    aliases?: string[];
+    inputs?: CommandInput[];
+    options?: CommandOption[];
+    fullName?: string;
+    visible?: boolean;
+    source?: string;
+    minimistOpts?: minimistType.Opts;
+}
+export interface ISession {
+    login(email: string, password: string): Promise<void>;
+    logout(): Promise<void>;
+    isLoggedIn(): Promise<boolean>;
+    getUserToken(): Promise<string>;
+    getAppUserToken(app_id?: string): Promise<string>;
+}
+export interface IShellRunOptions extends crossSpawnType.SpawnOptions {
+    showCommand?: boolean;
+    showExecution?: boolean;
+    showError?: boolean;
+    fatalOnNotFound?: boolean;
+    fatalOnError?: boolean;
+    truncateErrorOutput?: number;
+}
+export interface IShell {
+    run(command: string, args: string[], options: IShellRunOptions): Promise<string>;
+}
+export interface ITelemetry {
+    sendCommand(command: string, args: string[]): Promise<void>;
+    sendError(error: any, type: string): Promise<void>;
+    resetToken(): Promise<void>;
+}
+export interface ConfigFile {
+    lastCommand: string;
+    daemon: {
+        updates?: boolean;
+    };
+    urls: {
+        api: string;
+        dash: string;
+    };
+    git: {
+        host: string;
+        port?: number;
+        setup?: boolean;
+    };
+    user: {
+        id?: string;
+        email?: string;
+    };
+    tokens: {
+        user?: string;
+        telemetry?: string;
+        appUser: {
+            [app_id: string]: string;
+        };
+    };
+    backend: BackendFlag;
+    telemetry: boolean;
+    yarn: boolean;
+}
+export interface IConfig<T extends {
+    [key: string]: any;
+}> {
+    directory: string;
+    fileName: string;
+    filePath: string;
+    load(options?: {
+        disk?: boolean;
+    }): Promise<T>;
+    save(configFile?: T): Promise<void>;
+}
+export declare type APIResponse = APIResponseSuccess | APIResponseError;
+export interface APIResponseMeta {
+    status: number;
+    version: string;
+    request_id: string;
+}
+export declare type APIResponseData = Object | Object[] | string;
+export interface APIResponseErrorDetails {
+    error_type: string;
+    parameter: string;
+    errors: string[];
+}
+export interface APIResponseError {
+    error: APIResponseErrorError;
+    meta: APIResponseMeta;
+}
+export interface APIResponseErrorError {
+    message: string;
+    link: string | null;
+    type: string;
+    details?: APIResponseErrorDetails[];
+}
+export interface APIResponseSuccess {
+    data: APIResponseData;
+    meta: APIResponseMeta;
+}
+export declare type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE' | 'PURGE' | 'HEAD' | 'OPTIONS';
+export interface IClient {
+    host: string;
+    make(method: HttpMethod, path: string): superagentType.SuperAgentRequest;
+    do(req: superagentType.SuperAgentRequest): Promise<APIResponseSuccess>;
+    paginate<T extends Response<Object[]>>(reqgen: () => superagentType.SuperAgentRequest, guard: (res: APIResponseSuccess) => res is T): IPaginator<T>;
+}
+export interface IPaginator<T extends Response<Object[]>> extends IterableIterator<Promise<T>> {
+}
+export interface EnvironmentHookArgs {
+    env: IonicEnvironment;
+}
+export interface CommandHookArgs extends EnvironmentHookArgs {
+    cmd: ICommand;
+    inputs: CommandLineInputs;
+    options: CommandLineOptions;
+}
+export interface InfoHookItem {
+    type: 'system' | 'global-packages' | 'local-packages' | 'cli-packages';
+    name: string;
+    version: string;
+    path?: string;
+}
+export interface ConfigSetCommandHookArgs extends CommandHookArgs {
+    valueChanged: boolean;
+}
+export interface ServeCommandHookResponse {
+    protocol: string;
+    localAddress: string;
+    externalAddress: string;
+    port: number;
+    /**
+     * Whether or not the server is accessible locally.
+     */
+    locallyAccessible: boolean;
+    /**
+     * Whether or not the server is accessible externally.
+     */
+    externallyAccessible: boolean;
+    /**
+     * @deprecated
+     */
+    httpPort?: number;
+    /**
+     * @deprecated
+     */
+    publicIp?: string;
+    [key: string]: any;
+}
+export interface CordovaProjectInfoHookResponse {
+    id: string;
+    name: string;
+    version: string;
+}
+export interface IHook<T, U> {
+    source: string;
+    name: string;
+    fire(args: T): Promise<U>;
+}
+export interface IHookEngine {
+    fire(hook: 'cordova:project:info', args: EnvironmentHookArgs): Promise<CordovaProjectInfoHookResponse[]>;
+    fire(hook: 'plugins:init', args: EnvironmentHookArgs): Promise<void[]>;
+    fire(hook: 'command:config:set', args: ConfigSetCommandHookArgs): Promise<void[]>;
+    fire(hook: 'command:docs', args: CommandHookArgs): Promise<string[]>;
+    fire(hook: 'command:generate', args: CommandHookArgs): Promise<void[]>;
+    fire(hook: 'command:info', args: CommandHookArgs): Promise<InfoHookItem[][]>;
+    fire(hook: 'command:build', args: CommandHookArgs): Promise<void[]>;
+    fire(hook: 'command:serve', args: CommandHookArgs): Promise<ServeCommandHookResponse[]>;
+    fire(hook: 'build:before', args: EnvironmentHookArgs): Promise<void[]>;
+    fire(hook: 'build:after', args: EnvironmentHookArgs): Promise<void[]>;
+    fire(hook: 'watch:before', args: EnvironmentHookArgs): Promise<void[]>;
+    fire(hook: 'backend:changed', args: EnvironmentHookArgs): Promise<void[]>;
+    register(source: string, hook: 'cordova:project:info', listener: (args: EnvironmentHookArgs) => Promise<CordovaProjectInfoHookResponse>): void;
+    register(source: string, hook: 'plugins:init', listener: (args: EnvironmentHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'command:config:set', listener: (args: ConfigSetCommandHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'command:docs', listener: (args: CommandHookArgs) => Promise<string>): void;
+    register(source: string, hook: 'command:generate', listener: (args: CommandHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'command:info', listener: (args: CommandHookArgs) => Promise<InfoHookItem[]>): void;
+    register(source: string, hook: 'command:build', listener: (args: CommandHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'command:serve', listener: (args: CommandHookArgs) => Promise<ServeCommandHookResponse>): void;
+    register(source: string, hook: 'build:before', listener: (args: EnvironmentHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'build:after', listener: (args: EnvironmentHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'watch:before', listener: (args: EnvironmentHookArgs) => Promise<void>): void;
+    register(source: string, hook: 'backend:changed', listener: (args: EnvironmentHookArgs) => Promise<void>): void;
+    getSources(hook: string): string[];
+    hasSources(hook: string, sources: string[]): boolean;
+    deleteSource(source: string): void;
+    getRegistered<T, U>(hook: string): IHook<T, U>[];
+}
+export interface ICLIEventEmitter extends EventEmitter {
+    on(event: 'watch:init', listener: () => void): this;
+    on(event: 'watch:change', listener: (path: string) => void): this;
+    emit(event: 'watch:init'): boolean;
+    emit(event: 'watch:change', path: string): boolean;
+}
+export interface PromptQuestion extends inquirerType.Question {
+    type: string;
+    message: string;
+    name: string;
+}
+export interface ConfirmPromptQuestion extends PromptQuestion {
+    type: 'confirm';
+    noninteractiveValue?: boolean;
+}
+export interface NonConfirmPromptQuestion extends PromptQuestion {
+    type: 'input' | 'password' | 'list';
+    noninteractiveValue?: string;
+}
+export interface PromptModule {
+    (question: ConfirmPromptQuestion): Promise<boolean>;
+    (question: NonConfirmPromptQuestion): Promise<string>;
+}
+export interface IonicEnvironment {
+    readonly flags: IonicEnvironmentFlags;
+    readonly hooks: IHookEngine;
+    readonly client: IClient;
+    readonly config: IConfig<ConfigFile>;
+    readonly daemon: IDaemon;
+    readonly events: ICLIEventEmitter;
+    readonly log: ILogger;
+    readonly prompt: PromptModule;
+    readonly meta: IonicEnvironmentMeta;
+    project: IProject;
+    readonly plugins: IonicEnvironmentPlugins;
+    session: ISession;
+    readonly shell: IShell;
+    readonly tasks: ITaskChain;
+    readonly telemetry: ITelemetry;
+    readonly namespace: IRootNamespace;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    runcmd(pargv: string[], opts?: {
+        showExecution?: boolean;
+        showLogs?: boolean;
+    }): Promise<void>;
+    load(modulePath: 'semver'): typeof semverType;
+    load(modulePath: 'superagent'): typeof superagentType;
+    load(modulePath: 'lodash'): typeof lodashType;
+}
+export interface IonicEnvironmentFlags {
+    interactive: boolean;
+    confirm: boolean;
+}
+export interface IonicEnvironmentMeta {
+    cwd: string;
+    local: boolean;
+    binPath: string;
+    libPath: string;
+}
+export interface IonicEnvironmentPlugins {
+    ionic: Plugin;
+    [key: string]: Plugin;
+}
+export declare type DistTag = 'local' | 'canary' | 'beta' | 'latest';
+export interface PluginMeta {
+    filePath: string;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    namespace?: INamespace;
+    registerHooks?(hooks: IHookEngine): void;
+    meta?: PluginMeta;
+}
+export interface RootPlugin extends Plugin {
+    namespace: IRootNamespace;
+}
+export interface HydratedPlugin extends Plugin {
+    distTag: DistTag;
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+    meta: PluginMeta;
+}
+export interface INamespace {
+    root: boolean;
+    name: string;
+    namespaces: INamespaceMap;
+    commands: ICommandMap;
+    source: string;
+    locate(argv: string[]): [number, string[], ICommand | INamespace];
+    getCommandMetadataList(): CommandData[];
+}
+export interface IRootNamespace extends INamespace {
+    root: true;
+    name: 'ionic';
+    source: 'ionic';
+    runCommand(env: IonicEnvironment, pargv: string[]): Promise<void | number>;
+}
+export interface ICommand {
+    env: IonicEnvironment;
+    metadata: CommandData;
+    validate(inputs: CommandLineInputs): Promise<void>;
+    run(inputs: CommandLineInputs, options: CommandLineOptions): Promise<void | number>;
+    execute(inputs: CommandLineInputs, options: CommandLineOptions): Promise<void>;
+}
+export interface CommandPreRun extends ICommand {
+    preRun(inputs: CommandLineInputs, options: CommandLineOptions): Promise<void | number>;
+}
+export declare type NamespaceMapGetter = () => INamespace;
+export declare type CommandMapGetter = () => ICommand;
+export interface INamespaceMap extends Map<string, NamespaceMapGetter> {
+}
+export interface ICommandMap extends Map<string, string | CommandMapGetter> {
+    getAliases(): Map<string, string[]>;
+    resolveAliases(cmdName: string): undefined | CommandMapGetter;
+}

node_modules/@ionic/cli-utils/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@ionic/cli-utils/guards.d.ts

@@ -0,0 +1,41 @@
+import { APIResponse, APIResponseError, APIResponseSuccess, AppDetails, AuthToken, BowerJson, CommandPreRun, Deploy, DeployChannel, DeploySnapshot, DeploySnapshotRequest, ExitCodeException, ICommand, INamespace, LogLevel, PackageBuild, PackageJson, PackageProjectRequest, Plugin, Response, SSHKey, SecurityProfile, SuperAgentError, ValidationError } from './definitions';
+export declare const LOG_LEVELS: LogLevel[];
+export declare function isCommand(cmd: ICommand | INamespace): cmd is ICommand;
+export declare function isCommandPreRun(cmd: ICommand): cmd is CommandPreRun;
+export declare function isLogLevel(l: string): l is LogLevel;
+export declare function isPackageJson(o: Object): o is PackageJson;
+export declare function isBowerJson(o: Object): o is BowerJson;
+export declare function isExitCodeException(e: Error): e is ExitCodeException;
+export declare function isValidationErrorArray(e: Object[]): e is ValidationError[];
+export declare function isPlugin(p: any): p is Plugin;
+export declare function isSuperAgentError(e: Error): e is SuperAgentError;
+export declare function isAPIResponseSuccess(r: APIResponse): r is APIResponseSuccess;
+export declare function isAPIResponseError(r: APIResponse): r is APIResponseError;
+export declare function isAppDetails(d: Object): d is AppDetails;
+export declare function isAppResponse(r: APIResponse): r is Response<AppDetails>;
+export declare function isAppsResponse(r: APIResponse): r is Response<AppDetails[]>;
+export declare function isAuthTokensResponse(r: APIResponse): r is Response<AuthToken[]>;
+export declare function isLegacyLoginResponse(r: APIResponse): r is Response<{
+    user_id: string;
+    token: string;
+}>;
+export declare function isProLoginResponse(r: APIResponse): r is Response<{
+    user: {
+        id: number;
+        email: string;
+    };
+    token: string;
+}>;
+export declare function isSSHKeyListResponse(r: APIResponse): r is Response<SSHKey[]>;
+export declare function isSSHKeyResponse(r: APIResponse): r is Response<SSHKey>;
+export declare function isDeployResponse(r: APIResponse): r is Response<Deploy>;
+export declare function isPackageProjectRequestResponse(r: APIResponse): r is Response<PackageProjectRequest>;
+export declare function isPackageBuild(o: Object): o is PackageBuild;
+export declare function isSecurityProfile(o: Object): o is SecurityProfile;
+export declare function isSecurityProfileResponse(r: APIResponse): r is Response<SecurityProfile>;
+export declare function isSecurityProfilesResponse(r: APIResponse): r is Response<SecurityProfile[]>;
+export declare function isPackageBuildResponse(r: APIResponse): r is Response<PackageBuild>;
+export declare function isPackageBuildsResponse(r: APIResponse): r is Response<PackageBuild[]>;
+export declare function isDeployChannelResponse(r: APIResponse): r is Response<DeployChannel>;
+export declare function isDeploySnapshotResponse(r: APIResponse): r is Response<DeploySnapshot>;
+export declare function isDeploySnapshotRequestResponse(r: APIResponse): r is Response<DeploySnapshotRequest>;

node_modules/@ionic/cli-utils/guards.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVELS = ['debug', 'info', 'ok', 'warn', 'error'];
+function isCommand(cmd) {
+    return typeof cmd.run === 'function';
+}
+exports.isCommand = isCommand;
+function isCommandPreRun(cmd) {
+    return typeof cmd.preRun === 'function';
+}
+exports.isCommandPreRun = isCommandPreRun;
+function isLogLevel(l) {
+    const loglevel = l;
+    return exports.LOG_LEVELS.includes(loglevel);
+}
+exports.isLogLevel = isLogLevel;
+function isPackageJson(o) {
+    const obj = o;
+    return obj && typeof obj.name === 'string';
+}
+exports.isPackageJson = isPackageJson;
+function isBowerJson(o) {
+    const obj = o;
+    return obj && typeof obj.name === 'string';
+}
+exports.isBowerJson = isBowerJson;
+function isExitCodeException(e) {
+    const err = e;
+    return err && typeof err.exitCode === 'number' && err.exitCode >= 0 && err.exitCode <= 255;
+}
+exports.isExitCodeException = isExitCodeException;
+function isValidationErrorArray(e) {
+    const err = e;
+    return err && err[0]
+        && typeof err[0].message === 'string'
+        && typeof err[0].inputName === 'string';
+}
+exports.isValidationErrorArray = isValidationErrorArray;
+function isPlugin(p) {
+    const plugin = p;
+    return plugin
+        && typeof plugin.name === 'string'
+        && typeof plugin.version === 'string';
+}
+exports.isPlugin = isPlugin;
+function isSuperAgentError(e) {
+    const err = e;
+    return e && err.response && typeof err.response === 'object';
+}
+exports.isSuperAgentError = isSuperAgentError;
+function isAPIResponseSuccess(r) {
+    const res = r;
+    return res && (typeof res.data === 'object' || typeof res.data === 'string');
+}
+exports.isAPIResponseSuccess = isAPIResponseSuccess;
+function isAPIResponseError(r) {
+    const res = r;
+    return res && typeof res.error === 'object';
+}
+exports.isAPIResponseError = isAPIResponseError;
+function isAppDetails(d) {
+    const details = d;
+    return details && typeof details === 'object'
+        && typeof details.id === 'string'
+        && typeof details.name === 'string'
+        && typeof details.slug === 'string';
+}
+exports.isAppDetails = isAppDetails;
+function isAppResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res) && isAppDetails(res.data);
+}
+exports.isAppResponse = isAppResponse;
+function isAppsResponse(r) {
+    let res = r;
+    if (!isAPIResponseSuccess(res) || !Array.isArray(res.data)) {
+        return false;
+    }
+    if (res.data.length > 0) {
+        return isAppDetails(res.data[0]);
+    }
+    return true;
+}
+exports.isAppsResponse = isAppsResponse;
+function isAuthTokensResponse(r) {
+    const res = r;
+    if (!isAPIResponseSuccess(res) || !Array.isArray(res.data)) {
+        return false;
+    }
+    if (res.data.length > 0) {
+        return typeof res.data[0].token === 'string'
+            && typeof res.data[0].details === 'object'
+            && typeof res.data[0].details.app_id === 'string'
+            && typeof res.data[0].details.type === 'string'
+            && typeof res.data[0].details.user_id === 'string';
+    }
+    return true;
+}
+exports.isAuthTokensResponse = isAuthTokensResponse;
+function isLegacyLoginResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(r) && typeof res.data.token === 'string';
+}
+exports.isLegacyLoginResponse = isLegacyLoginResponse;
+function isProLoginResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(r)
+        && typeof res.data.user === 'object'
+        && typeof res.data.user.id === 'number'
+        && typeof res.data.user.email === 'string'
+        && typeof res.data.token === 'string';
+}
+exports.isProLoginResponse = isProLoginResponse;
+function isSSHKeyListResponse(r) {
+    const res = r;
+    if (!isAPIResponseSuccess(r) || !Array.isArray(r.data)) {
+        return false;
+    }
+    if (typeof r.data[0] === 'object') {
+        return typeof res.data[0].id === 'string'
+            && typeof res.data[0].pubkey === 'string'
+            && typeof res.data[0].fingerprint === 'string'
+            && typeof res.data[0].annotation === 'string'
+            && typeof res.data[0].name === 'string'
+            && typeof res.data[0].created === 'string'
+            && typeof res.data[0].updated === 'string';
+    }
+    return true;
+}
+exports.isSSHKeyListResponse = isSSHKeyListResponse;
+function isSSHKeyResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(r)
+        && typeof res.data.id === 'string'
+        && typeof res.data.pubkey === 'string'
+        && typeof res.data.fingerprint === 'string'
+        && typeof res.data.annotation === 'string'
+        && typeof res.data.name === 'string'
+        && typeof res.data.created === 'string'
+        && typeof res.data.updated === 'string';
+}
+exports.isSSHKeyResponse = isSSHKeyResponse;
+function isDeployResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res)
+        && typeof res.data.uuid === 'string'
+        && typeof res.data.snapshot === 'string'
+        && typeof res.data.channel === 'string';
+}
+exports.isDeployResponse = isDeployResponse;
+function isPackageProjectRequestResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res)
+        && typeof res.data.id === 'number'
+        && typeof res.data.presigned_post === 'object'
+        && typeof res.data.presigned_post.url === 'string'
+        && res.data.presigned_post.fields && typeof res.data.presigned_post.fields === 'object';
+}
+exports.isPackageProjectRequestResponse = isPackageProjectRequestResponse;
+function isPackageBuild(o) {
+    const obj = o;
+    return obj && typeof obj === 'object'
+        && typeof obj.id === 'number'
+        && (!obj.name) || typeof obj.name === 'string'
+        && typeof obj.created === 'string'
+        && (!obj.completed || typeof obj.completed === 'string')
+        && typeof obj.platform === 'string'
+        && typeof obj.status === 'string'
+        && typeof obj.mode === 'string'
+        && (!obj.security_profile_tag || typeof obj.security_profile_tag === 'string')
+        && (!obj.url || typeof obj.url === 'string');
+}
+exports.isPackageBuild = isPackageBuild;
+function isSecurityProfile(o) {
+    const obj = o;
+    return obj && typeof obj === 'object'
+        && typeof obj.name === 'string'
+        && typeof obj.tag === 'string'
+        && typeof obj.type === 'string'
+        && typeof obj.created === 'string'
+        && typeof obj.credentials === 'object';
+}
+exports.isSecurityProfile = isSecurityProfile;
+function isSecurityProfileResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res) && isSecurityProfile(res.data);
+}
+exports.isSecurityProfileResponse = isSecurityProfileResponse;
+function isSecurityProfilesResponse(r) {
+    const res = r;
+    if (!isAPIResponseSuccess(res) || !Array.isArray(res.data)) {
+        return false;
+    }
+    if (res.data.length > 0) {
+        return isSecurityProfile(res.data[0]);
+    }
+    return true;
+}
+exports.isSecurityProfilesResponse = isSecurityProfilesResponse;
+function isPackageBuildResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res) && isPackageBuild(res.data);
+}
+exports.isPackageBuildResponse = isPackageBuildResponse;
+function isPackageBuildsResponse(r) {
+    const res = r;
+    if (!isAPIResponseSuccess(res) || !Array.isArray(res.data)) {
+        return false;
+    }
+    if (res.data.length > 0) {
+        return isPackageBuild(res.data[0]);
+    }
+    return true;
+}
+exports.isPackageBuildsResponse = isPackageBuildsResponse;
+function isDeployChannelResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res)
+        && typeof res.data.uuid === 'string'
+        && typeof res.data.tag === 'string';
+}
+exports.isDeployChannelResponse = isDeployChannelResponse;
+function isDeploySnapshotResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res)
+        && typeof res.data.uuid === 'string'
+        && typeof res.data.url === 'string';
+}
+exports.isDeploySnapshotResponse = isDeploySnapshotResponse;
+function isDeploySnapshotRequestResponse(r) {
+    const res = r;
+    return isAPIResponseSuccess(res)
+        && typeof res.data.uuid === 'string'
+        && typeof res.data.presigned_post === 'object'
+        && typeof res.data.presigned_post.url === 'string'
+        && res.data.presigned_post.fields && typeof res.data.presigned_post.fields === 'object';
+}
+exports.isDeploySnapshotRequestResponse = isDeploySnapshotRequestResponse;

node_modules/@ionic/cli-utils/index.d.ts

@@ -0,0 +1,44 @@
+import { IHookEngine, IonicEnvironment, RootPlugin } from './definitions';
+export * from './definitions';
+export * from './guards';
+export * from './lib/app';
+export * from './lib/backends';
+export * from './lib/command';
+export * from './lib/command/command';
+export * from './lib/command/namespace';
+export * from './lib/command/utils';
+export * from './lib/config';
+export * from './lib/daemon';
+export * from './lib/deploy';
+export * from './lib/errors';
+export * from './lib/events';
+export * from './lib/help';
+export * from './lib/hooks';
+export * from './lib/http';
+export * from './lib/login';
+export * from './lib/package';
+export * from './lib/plugins';
+export * from './lib/project';
+export * from './lib/prompts';
+export * from './lib/security';
+export * from './lib/session';
+export * from './lib/shell';
+export * from './lib/telemetry';
+export * from './lib/utils/archive';
+export * from './lib/utils/array';
+export * from './lib/utils/environmentInfo';
+export * from './lib/utils/format';
+export * from './lib/utils/fs';
+export * from './lib/utils/logger';
+export * from './lib/utils/network';
+export * from './lib/utils/npm';
+export * from './lib/utils/promise';
+export * from './lib/utils/string';
+export * from './lib/utils/task';
+export * from './lib/validators';
+export declare const name = "__NAME__";
+export declare const version = "__VERSION__";
+export declare function registerHooks(hooks: IHookEngine): void;
+export declare function generateIonicEnvironment(plugin: RootPlugin, pargv: string[], env: {
+    [key: string]: string;
+}): Promise<IonicEnvironment>;

node_modules/@ionic/cli-utils/index.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const util = require("util");
+const path = require("path");
+const ci_info_1 = require("ci-info");
+const chalk = require("chalk");
+const minimist = require("minimist");
+const guards_1 = require("./guards");
+const backends_1 = require("./lib/backends");
+const config_1 = require("./lib/config");
+const daemon_1 = require("./lib/daemon");
+const http_1 = require("./lib/http");
+const events_1 = require("./lib/events");
+const environment_1 = require("./lib/environment");
+const hooks_1 = require("./lib/hooks");
+const project_1 = require("./lib/project");
+const logger_1 = require("./lib/utils/logger");
+const fs_1 = require("./lib/utils/fs");
+const task_1 = require("./lib/utils/task");
+const telemetry_1 = require("./lib/telemetry");
+const session_1 = require("./lib/session");
+const shell_1 = require("./lib/shell");
+const prompts_1 = require("./lib/prompts");
+tslib_1.__exportStar(require("./guards"), exports);
+tslib_1.__exportStar(require("./lib/app"), exports);
+tslib_1.__exportStar(require("./lib/backends"), exports);
+tslib_1.__exportStar(require("./lib/command"), exports);
+tslib_1.__exportStar(require("./lib/command/command"), exports);
+tslib_1.__exportStar(require("./lib/command/namespace"), exports);
+tslib_1.__exportStar(require("./lib/command/utils"), exports);
+tslib_1.__exportStar(require("./lib/config"), exports);
+tslib_1.__exportStar(require("./lib/daemon"), exports);
+tslib_1.__exportStar(require("./lib/deploy"), exports);
+tslib_1.__exportStar(require("./lib/errors"), exports);
+tslib_1.__exportStar(require("./lib/events"), exports);
+tslib_1.__exportStar(require("./lib/help"), exports);
+tslib_1.__exportStar(require("./lib/hooks"), exports);
+tslib_1.__exportStar(require("./lib/http"), exports);
+tslib_1.__exportStar(require("./lib/login"), exports);
+tslib_1.__exportStar(require("./lib/package"), exports);
+tslib_1.__exportStar(require("./lib/plugins"), exports);
+tslib_1.__exportStar(require("./lib/project"), exports);
+tslib_1.__exportStar(require("./lib/prompts"), exports);
+tslib_1.__exportStar(require("./lib/security"), exports);
+tslib_1.__exportStar(require("./lib/session"), exports);
+tslib_1.__exportStar(require("./lib/shell"), exports);
+tslib_1.__exportStar(require("./lib/telemetry"), exports);
+tslib_1.__exportStar(require("./lib/utils/archive"), exports);
+tslib_1.__exportStar(require("./lib/utils/array"), exports);
+tslib_1.__exportStar(require("./lib/utils/environmentInfo"), exports);
+tslib_1.__exportStar(require("./lib/utils/format"), exports);
+tslib_1.__exportStar(require("./lib/utils/fs"), exports);
+tslib_1.__exportStar(require("./lib/utils/logger"), exports);
+tslib_1.__exportStar(require("./lib/utils/network"), exports);
+tslib_1.__exportStar(require("./lib/utils/npm"), exports);
+tslib_1.__exportStar(require("./lib/utils/promise"), exports);
+tslib_1.__exportStar(require("./lib/utils/string"), exports);
+tslib_1.__exportStar(require("./lib/utils/task"), exports);
+tslib_1.__exportStar(require("./lib/validators"), exports);
+exports.name = '@ionic/cli-utils';
+exports.version = '1.7.0';
+function registerHooks(hooks) {
+    hooks.register(exports.name, 'command:info', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return [
+            { type: 'cli-packages', name: exports.name, version: exports.version, path: path.dirname(__filename) },
+        ];
+    }));
+    hooks.register(exports.name, 'command:config:set', ({ env, inputs, options, valueChanged }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let [p] = inputs;
+        const { global } = options;
+        if (global && p === 'backend' && valueChanged) {
+            yield hooks.fire('backend:changed', { env });
+        }
+    }));
+    hooks.register(exports.name, 'backend:changed', ({ env }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        if (config.backend === backends_1.BACKEND_PRO) {
+            config.urls.api = 'https://api.ionicjs.com';
+            config.urls.dash = 'https://dashboard.ionicjs.com';
+        }
+        else if (config.backend === backends_1.BACKEND_LEGACY) {
+            config.urls.api = 'https://api.ionic.io';
+            config.urls.dash = 'https://apps.ionic.io';
+        }
+        const wasLoggedIn = yield env.session.isLoggedIn();
+        yield env.session.logout();
+        env.client.host = config.urls.api;
+        env.session = yield getSession(env.config, env.project, env.client);
+        if (wasLoggedIn) {
+            env.log.info('You have been logged out.');
+        }
+    }));
+}
+exports.registerHooks = registerHooks;
+function getSession(config, project, client) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const configData = yield config.load();
+        return configData.backend === backends_1.BACKEND_LEGACY ? new session_1.CloudSession(config, project, client) : new session_1.ProSession(config, project, client);
+    });
+}
+function generateIonicEnvironment(plugin, pargv, env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const argv = minimist(pargv, { boolean: true, string: '_' });
+        const config = new config_1.Config(env['IONIC_CONFIG_DIRECTORY'] || config_1.CONFIG_DIRECTORY, config_1.CONFIG_FILE);
+        const configData = yield config.load();
+        const flags = config_1.gatherFlags(argv);
+        let stream;
+        let tasks;
+        let bottomBar;
+        let log;
+        let level = 'info';
+        let levelInvalid = false;
+        let prefix = '';
+        if (ci_info_1.isCI) {
+            flags.interactive = false;
+        }
+        if (argv['log-level']) {
+            if (guards_1.isLogLevel(argv['log-level'])) {
+                level = argv['log-level'];
+            }
+            else {
+                levelInvalid = true;
+            }
+        }
+        if (argv['log-timestamps']) {
+            prefix = () => `${chalk.dim('[' + new Date().toISOString() + ']')}`;
+        }
+        if (flags.interactive) {
+            const inquirer = yield Promise.resolve().then(function () { return require('inquirer'); });
+            bottomBar = new inquirer.ui.BottomBar();
+            stream = bottomBar.log;
+            log = new logger_1.Logger({ level, prefix, stream });
+            tasks = new task_1.InteractiveTaskChain({ log, bottomBar });
+        }
+        else {
+            stream = process.stdout;
+            log = new logger_1.Logger({ level, prefix, stream });
+            tasks = new task_1.TaskChain({ log });
+        }
+        const projectDir = yield fs_1.findBaseDirectory(cwd, project_1.PROJECT_FILE);
+        env['IONIC_PROJECT_DIR'] = projectDir || '';
+        env['IONIC_PROJECT_FILE'] = project_1.PROJECT_FILE;
+        const project = new project_1.Project(env['IONIC_PROJECT_DIR'], project_1.PROJECT_FILE);
+        const client = new http_1.Client(configData.urls.api);
+        const session = yield getSession(config, project, client);
+        const hooks = new hooks_1.HookEngine();
+        const telemetry = new telemetry_1.Telemetry({ config, client, plugin, project, session });
+        const shell = new shell_1.Shell(tasks, log);
+        registerHooks(hooks);
+        const ienv = new environment_1.Environment({
+            bottomBar,
+            client,
+            config,
+            daemon: new daemon_1.Daemon(config_1.CONFIG_DIRECTORY, daemon_1.DAEMON_JSON_FILE),
+            events: new events_1.CLIEventEmitter(),
+            flags,
+            hooks,
+            log,
+            meta: {
+                cwd,
+                local: env['IONIC_CLI_LOCAL'] ? true : false,
+                binPath: env['IONIC_CLI_BIN'],
+                libPath: env['IONIC_CLI_LIB'],
+            },
+            namespace: plugin.namespace,
+            plugins: {
+                ionic: plugin,
+            },
+            prompt: yield prompts_1.createPromptModule({ confirm: flags.confirm, interactive: flags.interactive, log, config }),
+            project,
+            session,
+            shell,
+            tasks,
+            telemetry,
+        });
+        ienv.open();
+        if (levelInvalid) {
+            log.warn(`${chalk.green(argv['log-level'])} is an invalid log level--defaulting back to ${chalk.bold(level)}.\n` +
+                `You can choose from the following log levels: ${guards_1.LOG_LEVELS.map(l => chalk.bold(l)).join(', ')}.`);
+        }
+        log.debug(`CLI flags: ${util.inspect(flags, { breakLength: Infinity, colors: chalk.enabled })}`);
+        if (typeof argv['yarn'] === 'boolean') {
+            log.warn(`${chalk.green('--yarn')} / ${chalk.green('--no-yarn')} switch is deprecated. Use ${chalk.green('ionic config set -g yarn ' + String(argv['yarn']))}.`);
+            configData.yarn = argv['yarn'];
+        }
+        if (!projectDir) {
+            const foundDir = yield fs_1.findBaseDirectory(cwd, project_1.PROJECT_FILE_LEGACY);
+            if (foundDir) {
+                log.warn(`${chalk.bold(project_1.PROJECT_FILE_LEGACY)} file found in ${chalk.bold(foundDir)}--please rename it to ${chalk.bold(project_1.PROJECT_FILE)}, or your project directory will not be detected!`);
+            }
+        }
+        return ienv;
+    });
+}
+exports.generateIonicEnvironment = generateIonicEnvironment;

node_modules/@ionic/cli-utils/lib/app.d.ts

@@ -0,0 +1,7 @@
+import { AppDetails, IApp, IClient } from '../definitions';
+export declare class App implements IApp {
+    protected appUserToken: string;
+    protected client: IClient;
+    constructor(appUserToken: string, client: IClient);
+    load(app_id: string): Promise<AppDetails>;
+}

node_modules/@ionic/cli-utils/lib/app.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const http_1 = require("./http");
+const guards_1 = require("../guards");
+class App {
+    constructor(appUserToken, client) {
+        this.appUserToken = appUserToken;
+        this.client = client;
+    }
+    load(app_id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('GET', `/apps/${app_id}`)
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send({});
+            const res = yield this.client.do(req);
+            if (!guards_1.isAppResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+}
+exports.App = App;

node_modules/@ionic/cli-utils/lib/backends.d.ts

@@ -0,0 +1,3 @@
+import { BackendFlag } from '../definitions';
+export declare const BACKEND_LEGACY: BackendFlag;
+export declare const BACKEND_PRO: BackendFlag;

node_modules/@ionic/cli-utils/lib/backends.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACKEND_LEGACY = 'legacy';
+exports.BACKEND_PRO = 'pro';

node_modules/@ionic/cli-utils/lib/command/command.d.ts

@@ -0,0 +1,18 @@
+import { CommandData, CommandLineInputs, CommandLineOptions, ICommand, IonicEnvironment } from '../../definitions';
+import { FatalException } from '../errors';
+export declare class Command implements ICommand {
+    env: IonicEnvironment;
+    metadata: CommandData;
+    run(inputs: CommandLineInputs, options: CommandLineOptions): Promise<void | number>;
+    runwrap(fn: () => Promise<void | number>, opts?: {
+        exit0?: boolean;
+    }): Promise<void>;
+    runcmd(pargv: string[], opts?: {
+        showExecution?: boolean;
+        showLogs?: boolean;
+    }): Promise<void>;
+    validate(inputs: CommandLineInputs): Promise<void>;
+    execute(inputs: CommandLineInputs, options: CommandLineOptions): Promise<void>;
+    exit(msg: string, code?: number): FatalException;
+    getCleanInputsForTelemetry(inputs: CommandLineInputs, options: CommandLineOptions): Promise<string[]>;
+}

node_modules/@ionic/cli-utils/lib/command/command.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const guards_1 = require("../../guards");
+const errors_1 = require("../errors");
+const validators_1 = require("../validators");
+const utils_1 = require("./utils");
+class Command {
+    run(inputs, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () { });
+    }
+    runwrap(fn, opts = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (typeof opts.exit0 === 'undefined') {
+                opts.exit0 = true;
+            }
+            const r = yield fn();
+            if (typeof r === 'number' && (r > 0 || (r === 0 && opts.exit0))) {
+                throw this.exit('', r);
+            }
+        });
+    }
+    runcmd(pargv, opts = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.runwrap(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                yield this.env.runcmd(pargv, opts);
+            }), { exit0: false });
+        });
+    }
+    validate(inputs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            utils_1.validateInputs(inputs, this.metadata);
+        });
+    }
+    execute(inputs, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.env.config.load();
+            yield this.runwrap(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (guards_1.isCommandPreRun(this)) {
+                    return this.preRun(inputs, options);
+                }
+            }));
+            if (this.metadata.inputs) {
+                for (let input of this.metadata.inputs) {
+                    if (!input.validators) {
+                        input.validators = [];
+                    }
+                    if (input.required !== false) {
+                        input.validators.unshift(validators_1.validators.required);
+                    }
+                }
+                try {
+                    // Validate inputs again, this time with required validator (prompt input
+                    // should've happened in preRun)
+                    utils_1.validateInputs(inputs, this.metadata);
+                }
+                catch (e) {
+                    if (!this.env.flags.interactive) {
+                        this.env.log.warn(`Command ran non-interactively due to ${chalk.green('--no-interactive')} (or CI detected).`);
+                    }
+                    throw e;
+                }
+            }
+            const runPromise = (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                yield this.runwrap(() => this.run(inputs, options));
+            }))();
+            const telemetryPromise = (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (config.telemetry !== false) {
+                    let cmdInputs = [];
+                    if (this.metadata.name === 'login' || this.metadata.name === 'logout') {
+                        yield runPromise;
+                    }
+                    else if (this.metadata.name === 'help') {
+                        cmdInputs = inputs;
+                    }
+                    else {
+                        cmdInputs = yield this.getCleanInputsForTelemetry(inputs, options);
+                    }
+                    yield this.env.telemetry.sendCommand(`ionic ${this.metadata.fullName}`, cmdInputs);
+                }
+            }))();
+            yield Promise.all([runPromise, telemetryPromise]);
+        });
+    }
+    exit(msg, code = 1) {
+        return new errors_1.FatalException(msg, code);
+    }
+    getCleanInputsForTelemetry(inputs, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const initialOptions = { _: [] };
+            const filteredInputs = inputs.filter((input, i) => !this.metadata.inputs || (this.metadata.inputs[i] && !this.metadata.inputs[i].private));
+            const filteredOptions = Object.keys(options)
+                .filter(optionName => {
+                const metadataOption = this.metadata.options && this.metadata.options.find((o) => {
+                    return o.name === optionName || (typeof o.aliases !== 'undefined' && o.aliases.includes(optionName));
+                });
+                if (metadataOption && metadataOption.aliases && metadataOption.aliases.includes(optionName)) {
+                    return false; // exclude aliases
+                }
+                if (!metadataOption) {
+                    return true; // include unknown options
+                }
+                if (metadataOption.private) {
+                    return false; // exclude private options
+                }
+                if (typeof metadataOption.default !== 'undefined' && metadataOption.default === options[optionName]) {
+                    return false; // exclude options that match their default value (means it wasn't supplied by user)
+                }
+                return true;
+            })
+                .reduce((allOptions, optionName) => {
+                allOptions[optionName] = options[optionName];
+                return allOptions;
+            }, initialOptions);
+            const optionInputs = utils_1.minimistOptionsToArray(filteredOptions, { useDoubleQuotes: true });
+            return filteredInputs.concat(optionInputs);
+        });
+    }
+}
+exports.Command = Command;

node_modules/@ionic/cli-utils/lib/command/index.d.ts

@@ -0,0 +1,2 @@
+import { CommandData } from '../../definitions';
+export declare function CommandMetadata(metadata: CommandData): (target: Function) => void;

node_modules/@ionic/cli-utils/lib/command/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function CommandMetadata(metadata) {
+    return function (target) {
+        target.prototype.metadata = metadata;
+    };
+}
+exports.CommandMetadata = CommandMetadata;

node_modules/@ionic/cli-utils/lib/command/namespace.d.ts

@@ -0,0 +1,24 @@
+import { CommandData, CommandMapGetter, ICommand, INamespace, NamespaceMapGetter } from '../../definitions';
+export declare class CommandMap extends Map<string, string | CommandMapGetter> {
+    getAliases(): Map<string, string[]>;
+    resolveAliases(cmdName: string): undefined | CommandMapGetter;
+}
+export declare class NamespaceMap extends Map<string, NamespaceMapGetter> {
+}
+export declare class Namespace implements INamespace {
+    root: boolean;
+    name: string;
+    namespaces: NamespaceMap;
+    commands: CommandMap;
+    source: string;
+    /**
+     * Recursively inspect inputs supplied to walk down all the tree of
+     * namespaces available to find the command that we will execute or the
+     * right-most namespace matched if the command is not found.
+     */
+    locate(argv: string[]): [number, string[], ICommand | INamespace];
+    /**
+     * Get all command metadata in a flat structure.
+     */
+    getCommandMetadataList(): CommandData[];
+}

node_modules/@ionic/cli-utils/lib/command/namespace.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const string_1 = require("../utils/string");
+class CommandMap extends Map {
+    getAliases() {
+        const cmdAliases = new Map();
+        const cmdMapContents = Array.from(this.entries());
+        const aliasToCmd = cmdMapContents.filter((value) => typeof value[1] === 'string'); // TODO: typescript bug?
+        aliasToCmd.forEach(([alias, cmd]) => {
+            const aliases = cmdAliases.get(cmd) || [];
+            aliases.push(alias);
+            cmdAliases.set(cmd, aliases);
+        });
+        return cmdAliases;
+    }
+    resolveAliases(cmdName) {
+        const r = this.get(cmdName);
+        if (typeof r !== 'string') {
+            return r;
+        }
+        return this.resolveAliases(r);
+    }
+}
+exports.CommandMap = CommandMap;
+class NamespaceMap extends Map {
+}
+exports.NamespaceMap = NamespaceMap;
+class Namespace {
+    constructor() {
+        this.root = false;
+        this.name = '';
+        this.namespaces = new NamespaceMap();
+        this.commands = new CommandMap();
+        this.source = '';
+    }
+    /**
+     * Recursively inspect inputs supplied to walk down all the tree of
+     * namespaces available to find the command that we will execute or the
+     * right-most namespace matched if the command is not found.
+     */
+    locate(argv) {
+        function _locate(depth, inputs, ns, namespaceDepthList) {
+            const nsgetter = ns.namespaces.get(inputs[0]);
+            if (!nsgetter) {
+                const commands = ns.commands;
+                const cmdgetter = commands.resolveAliases(inputs[0]);
+                if (cmdgetter) {
+                    const cmd = cmdgetter();
+                    cmd.metadata.source = ns.source;
+                    cmd.metadata.fullName = [...namespaceDepthList.slice(1), cmd.metadata.name].join(' ');
+                    return [depth + 1, inputs.slice(1), cmd];
+                }
+                return [depth, inputs, ns];
+            }
+            const newNamespace = nsgetter();
+            return _locate(depth + 1, inputs.slice(1), newNamespace, [...namespaceDepthList, newNamespace.name]);
+        }
+        return _locate(0, argv, this, [this.name]);
+    }
+    /**
+     * Get all command metadata in a flat structure.
+     */
+    getCommandMetadataList() {
+        function _getCommandMetadataList(namespace, namespaceDepthList) {
+            const commandList = [];
+            const aliases = namespace.commands.getAliases();
+            // Gather all commands for a namespace and turn them into simple key value
+            // objects. Also keep a record of the namespace path.
+            namespace.commands.forEach((cmdgetter) => {
+                if (typeof cmdgetter === 'string') {
+                    return;
+                }
+                const cmd = cmdgetter();
+                cmd.metadata.source = namespace.source;
+                cmd.metadata.fullName = [...namespaceDepthList.slice(1), cmd.metadata.name].join(' ');
+                cmd.metadata.aliases = aliases.get(cmd.metadata.name) || [];
+                commandList.push(cmd.metadata);
+            });
+            commandList.sort((a, b) => string_1.strcmp(a.name, b.name));
+            let namespacedCommandList = [];
+            // If this namespace has children then get their commands
+            if (namespace.namespaces.size > 0) {
+                namespace.namespaces.forEach((nsgetter) => {
+                    const ns = nsgetter();
+                    const cmds = _getCommandMetadataList(ns, [...namespaceDepthList, ns.name]);
+                    namespacedCommandList = namespacedCommandList.concat(cmds);
+                });
+            }
+            namespacedCommandList.sort((a, b) => string_1.strcmp(a.fullName, b.fullName));
+            return commandList.concat(namespacedCommandList);
+        }
+        return _getCommandMetadataList(this, [this.name]);
+    }
+}
+exports.Namespace = Namespace;

node_modules/@ionic/cli-utils/lib/command/utils.d.ts

@@ -0,0 +1,10 @@
+import * as dargsType from 'dargs';
+import * as minimistType from 'minimist';
+import { CommandData, CommandLineOptions } from '../../definitions';
+export interface MinimistOptionsToArrayOptions extends dargsType.Opts {
+    useDoubleQuotes?: boolean;
+}
+export declare function minimistOptionsToArray(options: CommandLineOptions, fnOptions?: MinimistOptionsToArrayOptions): string[];
+export declare function metadataToMinimistOptions(metadata: CommandData): minimistType.Opts;
+export declare function validateInputs(argv: string[], metadata: CommandData): void;
+export declare function filterOptionsByIntent(metadata: CommandData, options: CommandLineOptions, intentName?: string): CommandLineOptions;

node_modules/@ionic/cli-utils/lib/command/utils.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("../validators");
+const modules_1 = require("../modules");
+const typeDefaults = new Map()
+    .set(String, null)
+    .set(Boolean, false);
+function minimistOptionsToArray(options, fnOptions = {}) {
+    const dargs = modules_1.load('dargs');
+    if (typeof fnOptions.ignoreFalse === 'undefined') {
+        fnOptions.ignoreFalse = true;
+    }
+    if (fnOptions.useDoubleQuotes) {
+        fnOptions.useEquals = true;
+    }
+    let results = dargs(options, fnOptions);
+    results.splice(results.length - options._.length); // take out arguments
+    if (fnOptions.useDoubleQuotes) {
+        results = results.map(r => r.replace(/^(\-\-[A-Za-z0-9-]+)=(.+\s+.+)$/, '$1="$2"'));
+    }
+    return results;
+}
+exports.minimistOptionsToArray = minimistOptionsToArray;
+/**
+ * Takes a Minimist command option and normalizes its values.
+ */
+function normalizeOption(option) {
+    if (!option.type) {
+        option.type = String;
+    }
+    if (!option.default) {
+        option.default = typeDefaults.get(option.type);
+    }
+    if (!option.aliases) {
+        option.aliases = [];
+    }
+    return option;
+}
+function metadataToMinimistOptions(metadata) {
+    let options = {
+        string: ['_'],
+        boolean: [],
+        alias: {},
+        default: {}
+    };
+    if (!metadata.options) {
+        return { boolean: true, string: '_' };
+    }
+    for (let option of metadata.options.map(o => normalizeOption(o))) {
+        if (option.type === String) {
+            options.string.push(option.name);
+        }
+        else if (option.type === Boolean) {
+            options.boolean.push(option.name);
+        }
+        options.default[option.name] = option.default;
+        options.alias[option.name] = option.aliases;
+    }
+    return options;
+}
+exports.metadataToMinimistOptions = metadataToMinimistOptions;
+function validateInputs(argv, metadata) {
+    if (!metadata.inputs) {
+        return;
+    }
+    const errors = [];
+    for (let i in metadata.inputs) {
+        const input = metadata.inputs[i];
+        if (input.validators && input.validators.length > 0) {
+            const vnames = input.validators.map(v => v.name);
+            if (vnames.includes('required')) {
+                validators_1.validate(argv[i], input.name, [validators_1.validators.required], errors);
+            }
+            else {
+                if (argv[i]) {
+                    validators_1.validate(argv[i], input.name, input.validators, errors);
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw errors;
+    }
+}
+exports.validateInputs = validateInputs;
+function filterOptionsByIntent(metadata, options, intentName) {
+    const r = Object.keys(options).reduce((allOptions, optionName) => {
+        const metadataOptionFound = (metadata.options || []).find((mdOption) => (mdOption.name === optionName || (mdOption.aliases || []).includes(optionName)));
+        if (metadataOptionFound) {
+            if (intentName && metadataOptionFound.intent === intentName) {
+                allOptions[optionName] = options[optionName];
+            }
+            else if (!intentName && !metadataOptionFound.intent) {
+                allOptions[optionName] = options[optionName];
+            }
+        }
+        return allOptions;
+    }, {});
+    r._ = options._;
+    r['--'] = options['--'];
+    return r;
+}
+exports.filterOptionsByIntent = filterOptionsByIntent;

node_modules/@ionic/cli-utils/lib/config.d.ts

@@ -0,0 +1,27 @@
+import * as minimistType from 'minimist';
+import { ConfigFile, IConfig, IonicEnvironment } from '../definitions';
+export declare abstract class BaseConfig<T> implements IConfig<T> {
+    fileName: string;
+    directory: string;
+    filePath: string;
+    protected configFile?: T;
+    protected originalConfigFile?: {
+        [key: string]: any;
+    };
+    constructor(directory: string, fileName: string);
+    abstract provideDefaults(o: {
+        [key: string]: any;
+    }): Promise<T>;
+    abstract is(o: any): o is T;
+    load(options?: {
+        disk?: boolean;
+    }): Promise<T>;
+    save(configFile?: T): Promise<void>;
+}
+export declare const CONFIG_FILE = "config.json";
+export declare const CONFIG_DIRECTORY: string;
+export declare class Config extends BaseConfig<ConfigFile> {
+    provideDefaults(o: any): Promise<ConfigFile>;
+    is(j: any): j is ConfigFile;
+}
+export declare function gatherFlags(argv: minimistType.ParsedArgs): IonicEnvironment['flags'];

node_modules/@ionic/cli-utils/lib/config.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const backends_1 = require("./backends");
+const errors_1 = require("./errors");
+const format_1 = require("./utils/format");
+const fs_1 = require("./utils/fs");
+const modules_1 = require("./modules");
+class BaseConfig {
+    constructor(directory, fileName) {
+        this.fileName = fileName;
+        // TODO: better way to check if in project
+        if (directory) {
+            this.directory = path.resolve(directory);
+        }
+        else {
+            this.directory = '';
+        }
+        this.filePath = path.resolve(this.directory, fileName);
+    }
+    load(options = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (options.disk || !this.configFile) {
+                let o;
+                try {
+                    const stats = yield fs_1.fsStat(this.filePath);
+                    if (stats.size < 5) {
+                        o = {};
+                    }
+                }
+                catch (e) {
+                    if (e.code !== 'ENOENT') {
+                        throw e;
+                    }
+                    o = {};
+                }
+                if (typeof o === 'undefined') {
+                    try {
+                        o = yield fs_1.fsReadJsonFile(this.filePath);
+                    }
+                    catch (e) {
+                        if (e === fs_1.ERROR_FILE_INVALID_JSON) {
+                            throw new errors_1.FatalException(`The config file (${chalk.bold(format_1.prettyPath(this.filePath))}) is not valid JSON format.\n\n` +
+                                `Please fix any JSON errors in the file.`);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                const lodash = modules_1.load('lodash');
+                this.originalConfigFile = lodash.cloneDeep(o);
+                o = yield this.provideDefaults(o);
+                if (this.is(o)) {
+                    this.configFile = o;
+                }
+                else {
+                    throw new errors_1.FatalException(`The config file (${chalk.bold(format_1.prettyPath(this.filePath))}) has an unrecognized JSON format.\n\n` +
+                        `This usually means a key had an unexpected value. Please look through it and fix any issues.\n` +
+                        `If all else fails--the CLI will recreate the file if you delete it.`);
+                }
+            }
+            return this.configFile;
+        });
+    }
+    save(configFile) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!configFile) {
+                configFile = this.configFile;
+            }
+            if (configFile) {
+                const lodash = modules_1.load('lodash');
+                if (!lodash.isEqual(configFile, this.originalConfigFile)) {
+                    const dirPath = path.dirname(this.filePath);
+                    try {
+                        const stats = yield fs_1.fsStat(dirPath);
+                        if (!stats.isDirectory()) {
+                            throw `${dirPath} must be a directory it is currently a file`;
+                        }
+                    }
+                    catch (e) {
+                        if (e.code !== 'ENOENT') {
+                            throw e;
+                        }
+                        yield fs_1.fsMkdirp(dirPath);
+                    }
+                    yield fs_1.fsWriteJsonFile(this.filePath, configFile, { encoding: 'utf8' });
+                    this.configFile = configFile;
+                    this.originalConfigFile = lodash.cloneDeep(configFile);
+                }
+            }
+        });
+    }
+}
+exports.BaseConfig = BaseConfig;
+exports.CONFIG_FILE = 'config.json';
+exports.CONFIG_DIRECTORY = path.resolve(os.homedir(), '.ionic');
+class Config extends BaseConfig {
+    provideDefaults(o) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const lodash = modules_1.load('lodash');
+            const results = lodash.cloneDeep(o);
+            if (!results.lastCommand) {
+                results.lastCommand = new Date().toISOString();
+            }
+            if (!results.daemon) {
+                results.daemon = {};
+            }
+            if (!results.urls) {
+                results.urls = {};
+            }
+            if (!results.git) {
+                results.git = {};
+            }
+            if (!results.git.host) {
+                results.git.host = 'git.ionicjs.com';
+            }
+            if (!results.urls.api) {
+                results.urls.api = 'https://api.ionic.io';
+            }
+            if (!results.urls.dash) {
+                results.urls.dash = 'https://apps.ionic.io';
+            }
+            if (!results.user) {
+                results.user = {};
+            }
+            if (!results.tokens) {
+                results.tokens = {};
+            }
+            if (!results.tokens.appUser) {
+                results.tokens.appUser = {};
+            }
+            if (typeof results.backend !== 'string') {
+                results.backend = backends_1.BACKEND_LEGACY;
+            }
+            if (typeof results.telemetry === 'undefined') {
+                if (results.cliFlags && typeof results.cliFlags.enableTelemetry !== 'undefined') {
+                    results.telemetry = results.cliFlags.enableTelemetry;
+                }
+                else if (results.cliFlags && typeof results.cliFlags.telemetry !== 'undefined') {
+                    results.telemetry = results.cliFlags.telemetry;
+                }
+                else {
+                    results.telemetry = true;
+                }
+            }
+            if (typeof results.yarn === 'undefined') {
+                if (results.cliFlags && typeof results.cliFlags.yarn !== 'undefined') {
+                    results.yarn = results.cliFlags.yarn;
+                }
+                else {
+                    results.yarn = false;
+                }
+            }
+            delete results.lastUpdated;
+            results.cliFlags = {}; // TODO: this is temporary
+            return results;
+        });
+    }
+    is(j) {
+        return j
+            && typeof j.lastCommand === 'string'
+            && typeof j.daemon === 'object'
+            && typeof j.urls === 'object'
+            && typeof j.urls.api === 'string'
+            && typeof j.urls.dash === 'string'
+            && typeof j.user === 'object'
+            && typeof j.tokens === 'object'
+            && typeof j.tokens.appUser === 'object'
+            && typeof j.backend === 'string'
+            && typeof j.telemetry === 'boolean'
+            && typeof j.yarn === 'boolean';
+    }
+}
+exports.Config = Config;
+function gatherFlags(argv) {
+    return {
+        interactive: typeof argv['interactive'] === 'undefined' ? true : argv['interactive'],
+        confirm: typeof argv['confirm'] === 'undefined' ? false : argv['confirm'],
+    };
+}
+exports.gatherFlags = gatherFlags;

node_modules/@ionic/cli-utils/lib/daemon.d.ts

@@ -0,0 +1,16 @@
+import { DaemonFile, DistTag, IonicEnvironment } from '../definitions';
+import { BaseConfig } from './config';
+export declare const DAEMON_PID_FILE = "daemon.pid";
+export declare const DAEMON_JSON_FILE = "daemon.json";
+export declare const DAEMON_LOG_FILE = "daemon.log";
+export declare class Daemon extends BaseConfig<DaemonFile> {
+    readonly pidFilePath: string;
+    readonly logFilePath: string;
+    getPid(): Promise<number | undefined>;
+    setPid(pid: number): Promise<void>;
+    provideDefaults(o: any): Promise<DaemonFile>;
+    populateDistTag(distTag: DistTag): void;
+    is(j: any): j is DaemonFile;
+}
+export declare function processRunning(pid: number): boolean;
+export declare function checkForDaemon(env: IonicEnvironment): Promise<number>;

node_modules/@ionic/cli-utils/lib/daemon.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = require("path");
+const chalk = require("chalk");
+const config_1 = require("./config");
+const fs_1 = require("./utils/fs");
+const plugins_1 = require("./plugins");
+const modules_1 = require("./modules");
+const KNOWN_PACKAGES = [
+    ...[].concat(plugins_1.KNOWN_COMMAND_PLUGINS, plugins_1.KNOWN_GLOBAL_PLUGINS, plugins_1.KNOWN_PROJECT_PLUGINS).map(plugins_1.formatFullPluginName),
+    '@ionic/cli-utils',
+    'ionic',
+];
+exports.DAEMON_PID_FILE = 'daemon.pid';
+exports.DAEMON_JSON_FILE = 'daemon.json';
+exports.DAEMON_LOG_FILE = 'daemon.log';
+class Daemon extends config_1.BaseConfig {
+    get pidFilePath() {
+        return path.join(this.directory, exports.DAEMON_PID_FILE);
+    }
+    get logFilePath() {
+        return path.join(this.directory, exports.DAEMON_LOG_FILE);
+    }
+    getPid() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const f = yield fs_1.fsReadFile(this.pidFilePath, { encoding: 'utf8' });
+                return Number(f);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    throw e;
+                }
+            }
+        });
+    }
+    setPid(pid) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield fs_1.fsWriteFile(this.pidFilePath, String(pid), { encoding: 'utf8' });
+        });
+    }
+    provideDefaults(o) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const lodash = modules_1.load('lodash');
+            const results = lodash.cloneDeep(o);
+            if (!results.daemonVersion) {
+                results.daemonVersion = '';
+            }
+            if (!results.latestVersions) {
+                results.latestVersions = {};
+            }
+            if (!results.latestVersions.latest) {
+                results.latestVersions.latest = {};
+            }
+            for (let pkg of KNOWN_PACKAGES) {
+                if (typeof results.latestVersions.latest[pkg] === 'undefined') {
+                    results.latestVersions.latest[pkg] = '';
+                }
+            }
+            return results;
+        });
+    }
+    populateDistTag(distTag) {
+        if (this.configFile) {
+            if (typeof this.configFile.latestVersions[distTag] === 'undefined') {
+                this.configFile.latestVersions[distTag] = {};
+            }
+            for (let pkg of KNOWN_PACKAGES) {
+                if (typeof this.configFile.latestVersions[distTag][pkg] === 'undefined') {
+                    this.configFile.latestVersions[distTag][pkg] = '';
+                }
+            }
+        }
+    }
+    is(j) {
+        return j
+            && typeof j.latestVersions === 'object'
+            && typeof j.latestVersions.latest === 'object';
+    }
+}
+exports.Daemon = Daemon;
+function processRunning(pid) {
+    try {
+        const r = process.kill(pid, 0);
+        if (typeof r === 'boolean') {
+            return r;
+        }
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+exports.processRunning = processRunning;
+function checkForDaemon(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        if (!config.daemon.updates) {
+            return 0;
+        }
+        const f = yield env.daemon.getPid();
+        if (f && processRunning(f)) {
+            env.log.debug(() => `Daemon found (pid: ${chalk.bold(String(f))})`);
+            return f;
+        }
+        const crossSpawn = modules_1.load('cross-spawn');
+        const fd = yield fs_1.fsOpen(env.daemon.logFilePath, 'a');
+        const crossSpawnOptions = {
+            cwd: env.config.directory,
+            stdio: ['ignore', fd, fd],
+        };
+        // TODO: should cross-spawn figure this stuff out? https://github.com/IndigoUnited/node-cross-spawn/issues/77
+        if (process.platform === 'win32') {
+            crossSpawnOptions.shell = true;
+            crossSpawnOptions.detached = false;
+        }
+        const crossSpawnArgs = [crossSpawnOptions.shell ? `"${env.meta.binPath}"` : env.meta.binPath, 'daemon', '--verbose', '--no-interactive', '--log-timestamps'];
+        const p = crossSpawn.spawn(crossSpawnOptions.shell ? `"${process.execPath}"` : process.execPath, crossSpawnArgs, crossSpawnOptions);
+        p.unref();
+        env.log.debug(`New daemon pid: ${chalk.bold(String(p.pid))}`);
+        return p.pid;
+    });
+}
+exports.checkForDaemon = checkForDaemon;

node_modules/@ionic/cli-utils/lib/deploy.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { Deploy, DeployChannel, DeploySnapshot, DeploySnapshotRequest, IClient } from '../definitions';
+export declare class DeployClient {
+    protected appUserToken: string;
+    protected client: IClient;
+    constructor(appUserToken: string, client: IClient);
+    getChannel(uuidOrTag: string): Promise<DeployChannel>;
+    deploy(snapshot: string, channel: string): Promise<Deploy>;
+    getSnapshot(uuid: string, {fields}: {
+        fields?: string[];
+    }): Promise<DeploySnapshot>;
+    requestSnapshotUpload(options?: {
+        legacy_duplication?: string;
+        note?: string;
+        user_metadata?: Object;
+    }): Promise<DeploySnapshotRequest>;
+    uploadSnapshot(snapshot: DeploySnapshotRequest, zip: NodeJS.ReadableStream, progress?: (loaded: number, total: number) => void): Promise<void>;
+}

node_modules/@ionic/cli-utils/lib/deploy.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const guards_1 = require("../guards");
+const http_1 = require("./http");
+const aws_1 = require("./utils/aws");
+class DeployClient {
+    constructor(appUserToken, client) {
+        this.appUserToken = appUserToken;
+        this.client = client;
+    }
+    getChannel(uuidOrTag) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('GET', `/deploy/channels/${uuidOrTag}`)
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isDeployChannelResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    deploy(snapshot, channel) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('POST', '/deploy/deploys')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send({ snapshot, channel });
+            const res = yield this.client.do(req);
+            if (!guards_1.isDeployResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    getSnapshot(uuid, { fields = [] }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (fields.indexOf('url') === -1) {
+                fields.push('url');
+            }
+            const req = this.client.make('GET', `/deploy/snapshots/${uuid}`)
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .query({ fields })
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isDeploySnapshotResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    requestSnapshotUpload(options = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            options.legacy_duplication = '1';
+            const req = this.client.make('POST', '/deploy/snapshots')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send(options);
+            const res = yield this.client.do(req);
+            if (!guards_1.isDeploySnapshotRequestResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            // TODO: Remove updateMetaDataReq when POST -> deploy/snapshots accepts user_metadata
+            if (options.user_metadata) {
+                const updateMetaDataReq = this.client.make('PATCH', `/deploy/snapshots/${res.data.uuid}`)
+                    .set('Authorization', `Bearer ${this.appUserToken}`)
+                    .send({
+                    'user_metadata': options.user_metadata
+                });
+                yield this.client.do(updateMetaDataReq);
+            }
+            return res.data;
+        });
+    }
+    uploadSnapshot(snapshot, zip, progress) {
+        return aws_1.s3SignedUpload(snapshot.presigned_post, zip, { progress });
+    }
+}
+exports.DeployClient = DeployClient;

node_modules/@ionic/cli-utils/lib/environment.d.ts

@@ -0,0 +1,47 @@
+import * as inquirerType from 'inquirer';
+import { ConfigFile, ICLIEventEmitter, IClient, IConfig, IDaemon, IHookEngine, ILogger, IProject, IRootNamespace, ISession, IShell, ITaskChain, ITelemetry, IonicEnvironment, IonicEnvironmentFlags, IonicEnvironmentMeta, IonicEnvironmentPlugins, PromptModule } from '../definitions';
+export declare class Environment implements IonicEnvironment {
+    readonly flags: IonicEnvironmentFlags;
+    readonly hooks: IHookEngine;
+    readonly client: IClient;
+    readonly config: IConfig<ConfigFile>;
+    readonly daemon: IDaemon;
+    readonly events: ICLIEventEmitter;
+    readonly log: ILogger;
+    readonly prompt: PromptModule;
+    readonly meta: IonicEnvironmentMeta;
+    project: IProject;
+    readonly plugins: IonicEnvironmentPlugins;
+    session: ISession;
+    readonly shell: IShell;
+    readonly tasks: ITaskChain;
+    readonly telemetry: ITelemetry;
+    readonly namespace: IRootNamespace;
+    private bottomBar?;
+    constructor({bottomBar, client, config, daemon, events, flags, hooks, log, meta, namespace, plugins, project, prompt, session, shell, tasks, telemetry}: {
+        bottomBar?: inquirerType.ui.BottomBar;
+        client: IClient;
+        config: IConfig<ConfigFile>;
+        daemon: IDaemon;
+        events: ICLIEventEmitter;
+        flags: IonicEnvironmentFlags;
+        hooks: IHookEngine;
+        log: ILogger;
+        meta: IonicEnvironmentMeta;
+        namespace: IRootNamespace;
+        plugins: IonicEnvironmentPlugins;
+        project: IProject;
+        prompt: PromptModule;
+        session: ISession;
+        shell: IShell;
+        tasks: ITaskChain;
+        telemetry: ITelemetry;
+    });
+    load(p: any): any;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    runcmd(pargv: string[], opts?: {
+        showExecution?: boolean;
+        showLogs?: boolean;
+    }): Promise<void>;
+}

node_modules/@ionic/cli-utils/lib/environment.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const modules_1 = require("./modules");
+class Environment {
+    constructor({ bottomBar, client, config, daemon, events, flags, hooks, log, meta, namespace, plugins, project, prompt, session, shell, tasks, telemetry, }) {
+        this.bottomBar = bottomBar;
+        this.client = client;
+        this.config = config;
+        this.daemon = daemon;
+        this.events = events;
+        this.flags = flags;
+        this.hooks = hooks;
+        this.log = log;
+        this.meta = meta;
+        this.namespace = namespace;
+        this.plugins = plugins;
+        this.project = project;
+        this.prompt = prompt;
+        this.session = session;
+        this.shell = shell;
+        this.tasks = tasks;
+        this.telemetry = telemetry;
+    }
+    load(p) {
+        return modules_1.load(p);
+    }
+    open() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.flags.interactive) {
+                if (!this.bottomBar) {
+                    const inquirer = require('inquirer');
+                    this.bottomBar = new inquirer.ui.BottomBar();
+                }
+                try {
+                    // the mute() call appears to be necessary, otherwise when answering
+                    // inquirer prompts upon pressing enter, a copy of the prompt is
+                    // printed to the screen and looks gross
+                    const bottomBarHack = this.bottomBar;
+                    bottomBarHack.rl.output.mute();
+                }
+                catch (e) {
+                    console.error('EXCEPTION DURING BOTTOMBAR OUTPUT MUTE', e);
+                }
+            }
+            this.log.stream = typeof this.bottomBar === 'undefined' ? process.stdout : this.bottomBar.log;
+        });
+    }
+    close() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.tasks.cleanup();
+            // instantiating inquirer.ui.BottomBar hangs, so when close() is called,
+            // we close BottomBar streams and replace the log stream with stdout.
+            // This means inquirer shouldn't be used after command execution finishes
+            // (which could happen during long-running processes like serve).
+            if (this.bottomBar) {
+                this.bottomBar.close();
+                this.bottomBar = undefined;
+                this.log.stream = process.stdout;
+            }
+        });
+    }
+    runcmd(pargv, opts = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const logstream = this.log.stream;
+            if (typeof opts.showExecution === 'undefined') {
+                opts.showExecution = true;
+            }
+            if (typeof opts.showLogs === 'undefined') {
+                opts.showLogs = true;
+            }
+            if (!opts.showLogs) {
+                const DevNull = require('dev-null'); // TODO
+                this.log.stream = new DevNull();
+            }
+            if (opts.showExecution) {
+                this.log.msg(`> ${chalk.green([this.namespace.name, ...pargv].map(a => a.includes(' ') ? `"${a}"` : a).join(' '))}`);
+            }
+            yield this.namespace.runCommand(this, pargv);
+            this.log.stream = logstream;
+        });
+    }
+}
+exports.Environment = Environment;

node_modules/@ionic/cli-utils/lib/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class Exception extends Error {
+    message: string;
+    name: string;
+    stack: string;
+    constructor(message: string);
+    toString(): string;
+}
+export declare class FatalException extends Exception {
+    message: string;
+    exitCode: number;
+    fatal: boolean;
+    constructor(message: string, exitCode?: number);
+}
+export declare class ShellException extends Exception {
+    message: string;
+    exitCode: number;
+    constructor(message: string, exitCode?: number);
+}

node_modules/@ionic/cli-utils/lib/errors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Exception extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'Exception';
+        this.message = message;
+        this.stack = (new Error()).stack || '';
+    }
+    toString() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.Exception = Exception;
+class FatalException extends Exception {
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.message = message;
+        this.exitCode = exitCode;
+        this.fatal = true;
+    }
+}
+exports.FatalException = FatalException;
+class ShellException extends Exception {
+    constructor(message, exitCode = 0) {
+        super(message);
+        this.message = message;
+        this.exitCode = exitCode;
+    }
+}
+exports.ShellException = ShellException;

node_modules/@ionic/cli-utils/lib/events.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ICLIEventEmitter } from '../definitions';
+export declare class CLIEventEmitter extends EventEmitter implements ICLIEventEmitter {
+}

node_modules/@ionic/cli-utils/lib/events.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+class CLIEventEmitter extends events_1.EventEmitter {
+}
+exports.CLIEventEmitter = CLIEventEmitter;

node_modules/@ionic/cli-utils/lib/help.d.ts

@@ -0,0 +1,2 @@
+import { IonicEnvironment } from '../definitions';
+export declare function showHelp(env: IonicEnvironment, inputs: string[]): Promise<void | number>;

node_modules/@ionic/cli-utils/lib/help.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const stringWidth = require("string-width");
+const guards_1 = require("../guards");
+const backends_1 = require("./backends");
+const format_1 = require("./utils/format");
+const HELP_DOTS_WIDTH = 25;
+function showHelp(env, inputs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let code = 0;
+        // If there are no inputs then show global command details.
+        if (inputs.length === 0) {
+            return env.log.msg(yield getFormattedHelpDetails(env, env.namespace, inputs));
+        }
+        const [, slicedInputs, cmdOrNamespace] = env.namespace.locate(inputs);
+        if (!guards_1.isCommand(cmdOrNamespace)) {
+            let extra = '';
+            if (!env.project.directory) {
+                extra = '\nYou may need to be in an Ionic project directory.';
+            }
+            if (slicedInputs.length > 0) {
+                env.log.error(`Unable to find command: ${chalk.green(inputs.join(' '))}${extra}\n`);
+                code = 1;
+            }
+        }
+        env.log.msg(yield formatHelp(env, cmdOrNamespace, inputs));
+        return code;
+    });
+}
+exports.showHelp = showHelp;
+function formatHelp(env, cmdOrNamespace, inputs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // If the command is located on the global namespace then show its help
+        if (!guards_1.isCommand(cmdOrNamespace)) {
+            return getFormattedHelpDetails(env, cmdOrNamespace, inputs);
+        }
+        const command = cmdOrNamespace;
+        return formatCommandHelp(env, command.metadata);
+    });
+}
+function getFormattedHelpDetails(env, ns, inputs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const globalMetadata = ns.getCommandMetadataList();
+        const formatList = (details) => details.map(hd => `    ${hd}\n`).join('');
+        if (ns.root) {
+            const globalCommandDetails = yield getHelpDetails(env, globalMetadata, [cmd => cmd.type === 'global']);
+            const projectCommandDetails = yield getHelpDetails(env, globalMetadata, [cmd => cmd.type === 'project']);
+            return `${yield formatHeader(env)}\n\n` +
+                `  ${chalk.bold('Usage')}:\n\n` +
+                `${yield formatUsage(env)}\n` +
+                `  ${chalk.bold('Global Commands')}:\n\n` +
+                `${formatList(globalCommandDetails)}\n` +
+                `  ${chalk.bold('Project Commands')}:\n\n` +
+                `${env.project.directory ? formatList(projectCommandDetails) : '    You are not in a project directory.\n'}\n`;
+        }
+        else {
+            const commandDetails = yield getHelpDetails(env, globalMetadata, []);
+            return `\n  ${chalk.bold('Commands')}:\n\n` +
+                `${formatList(commandDetails)}\n`;
+        }
+    });
+}
+function formatUsage(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const options = ['--help', '--verbose', '--quiet', '--no-interactive', '--confirm'];
+        const usageLines = [
+            `<command> ${chalk.dim('[<args>]')} ${options.map(opt => chalk.dim('[' + opt + ']')).join(' ')} ${chalk.dim('[options]')}`,
+        ];
+        return usageLines.map(u => `    ${chalk.dim('$')} ${chalk.green('ionic ' + u)}`).join('\n') + '\n';
+    });
+}
+function formatHeader(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        const isLoggedIn = yield env.session.isLoggedIn();
+        return `   _             _
+  (_)           (_)
+   _  ___  _ __  _  ___
+  | |/ _ \\| '_ \\| |/ __|
+  | | (_) | | | | | (__
+  |_|\\___/|_| |_|_|\\___|  CLI ${config.backend === backends_1.BACKEND_PRO && isLoggedIn ? chalk.blue('PRO') + ' ' : ''}${env.plugins.ionic.version}\n`;
+    });
+}
+function getHelpDetails(env, commandMetadataList, filters = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        for (let f of filters) {
+            commandMetadataList = commandMetadataList.filter(f);
+        }
+        const foundCommandList = commandMetadataList.filter((cmd) => cmd.visible !== false && (!cmd.backends || cmd.backends.includes(config.backend)));
+        return getListOfCommandDetails(foundCommandList);
+    });
+}
+function formatCommandHelp(env, cmdMetadata) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!cmdMetadata.fullName) {
+            cmdMetadata.fullName = cmdMetadata.name;
+        }
+        const displayCmd = 'ionic ' + cmdMetadata.fullName;
+        const wrappedDescription = format_1.wordWrap(cmdMetadata.description, { indentation: displayCmd.length + 5 });
+        return `
+  ${chalk.bold(chalk.green(displayCmd) + ' - ' + wrappedDescription)}${formatLongDescription(cmdMetadata.longDescription)}
+  ` +
+            (yield formatCommandUsage(env, cmdMetadata)) +
+            (yield formatCommandInputs(env, cmdMetadata.inputs)) +
+            (yield formatCommandOptions(env, cmdMetadata.options)) +
+            (yield formatCommandExamples(env, cmdMetadata.exampleCommands, cmdMetadata.fullName));
+    });
+}
+function getListOfCommandDetails(cmdMetadataList) {
+    const fillStringArray = format_1.generateFillSpaceStringList(cmdMetadataList.map(cmdMd => cmdMd.fullName || cmdMd.name), HELP_DOTS_WIDTH, chalk.dim('.'));
+    return cmdMetadataList.map((cmdMd, index) => {
+        const description = cmdMd.description + `${cmdMd.aliases && cmdMd.aliases.length > 0 ? chalk.dim(' (alias' + (cmdMd.aliases.length === 1 ? '' : 'es') + ': ') + cmdMd.aliases.map((a) => chalk.green(a)).join(', ') + chalk.dim(')') : ''}`;
+        const wrappedDescription = format_1.wordWrap(description, { indentation: HELP_DOTS_WIDTH + 6 });
+        return `${chalk.green(cmdMd.fullName || '')} ${fillStringArray[index]} ${wrappedDescription}`;
+    });
+}
+function formatCommandUsage(env, cmdMetadata) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const formatInput = (input) => {
+            if (!env.flags.interactive && input.required !== false) {
+                return '<' + input.name + '>';
+            }
+            return '[<' + input.name + '>]';
+        };
+        const options = yield filterOptionsForHelp(env, cmdMetadata.options);
+        const usageLine = `${chalk.dim('$')} ${chalk.green('ionic ' + cmdMetadata.name + (typeof cmdMetadata.inputs === 'undefined' ? '' : ' ' + cmdMetadata.inputs.map(formatInput).join(' ')))} ${options.length > 0 ? chalk.green('[options]') : ''}`;
+        return `
+  ${chalk.bold('Usage')}:
+
+    ${usageLine}
+  `;
+    });
+}
+function formatLongDescription(longDescription) {
+    if (!longDescription) {
+        return '';
+    }
+    longDescription = longDescription.trim();
+    longDescription = format_1.wordWrap(longDescription, { indentation: 4 });
+    return '\n\n    ' + longDescription;
+}
+function formatCommandInputs(env, inputs = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (inputs.length === 0) {
+            return '';
+        }
+        const fillStrings = format_1.generateFillSpaceStringList(inputs.map(input => input.name), HELP_DOTS_WIDTH, chalk.dim('.'));
+        function inputLineFn({ name, description }, index) {
+            const optionList = chalk.green(`${name}`);
+            const wrappedDescription = format_1.wordWrap(description, { indentation: HELP_DOTS_WIDTH + 6 });
+            return `${optionList} ${fillStrings[index]} ${wrappedDescription}`;
+        }
+        return `
+  ${chalk.bold('Inputs')}:
+
+    ${inputs.map(inputLineFn).join(`
+    `)}
+  `;
+    });
+}
+function formatOptionDefault(opt) {
+    if (typeof opt.default === 'string') {
+        return chalk.dim(' (default: ') + chalk.green(opt.default) + chalk.dim(')');
+    }
+    else {
+        return '';
+    }
+}
+function formatOptionLine(opt) {
+    const showInverse = opt.type === Boolean && opt.default === true && opt.name.length > 1;
+    const optionList = (showInverse ? chalk.green(`--no-${opt.name}`) : chalk.green(`-${opt.name.length > 1 ? '-' : ''}${opt.name}`)) +
+        (!showInverse && opt.aliases && opt.aliases.length > 0 ? ', ' +
+            opt.aliases
+                .map((alias) => chalk.green(`-${alias}`))
+                .join(', ') : '');
+    const optionListLength = stringWidth(optionList);
+    const fullLength = optionListLength > HELP_DOTS_WIDTH ? optionListLength + 1 : HELP_DOTS_WIDTH;
+    const wrappedDescription = format_1.wordWrap(opt.description + formatOptionDefault(opt), { indentation: HELP_DOTS_WIDTH + 6 });
+    return `${optionList} ${Array(fullLength - optionListLength).fill(chalk.dim('.')).join('')} ${wrappedDescription}`;
+}
+function filterOptionsForHelp(env, options = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        return options.filter(opt => opt.visible !== false && (!opt.backends || opt.backends.includes(config.backend)));
+    });
+}
+function formatCommandOptions(env, options = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        options = yield filterOptionsForHelp(env, options);
+        if (options.length === 0) {
+            return '';
+        }
+        return `
+  ${chalk.bold('Options')}:
+
+    ${options.map(formatOptionLine).join(`
+    `)}
+  `;
+    });
+}
+function formatCommandExamples(env, exampleCommands, commandName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!Array.isArray(exampleCommands)) {
+            return '';
+        }
+        const exampleLines = exampleCommands.map(cmd => {
+            const sepIndex = cmd.indexOf(' -- ');
+            if (sepIndex === -1) {
+                cmd = chalk.green(cmd);
+            }
+            else {
+                cmd = chalk.green(cmd.substring(0, sepIndex)) + cmd.substring(sepIndex);
+            }
+            const wrappedCmd = format_1.wordWrap(cmd, { indentation: 12, append: ' \\' });
+            return `${chalk.dim('$')} ${chalk.green('ionic ' + commandName)} ${wrappedCmd}`;
+        });
+        return `
+  ${chalk.bold('Examples')}:
+
+    ${exampleLines.join(`
+    `)}
+  `;
+    });
+}

node_modules/@ionic/cli-utils/lib/hooks.d.ts

@@ -0,0 +1,17 @@
+import { IHook, IHookEngine } from '../definitions';
+export declare class Hook<T, U> implements IHook<T, U> {
+    source: string;
+    name: string;
+    protected callable: (args: T) => Promise<U>;
+    constructor(source: string, name: string, callable: (args: T) => Promise<U>);
+    fire(args: T): Promise<U>;
+}
+export declare class HookEngine implements IHookEngine {
+    private hooks;
+    register<T, U>(source: string, hook: string, listener: (args: T) => Promise<U>): void;
+    fire<T, U>(hook: string, args: T): Promise<U[]>;
+    getSources(hook: string): string[];
+    hasSources(hook: string, sources: string[]): boolean;
+    deleteSource(source: string): void;
+    getRegistered<T, U>(hook: string): IHook<T, U>[];
+}

node_modules/@ionic/cli-utils/lib/hooks.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+class Hook {
+    constructor(source, name, callable) {
+        this.source = source;
+        this.name = name;
+        this.callable = callable;
+    }
+    fire(args) {
+        return this.callable(args);
+    }
+}
+exports.Hook = Hook;
+class HookEngine {
+    constructor() {
+        this.hooks = new Map();
+    }
+    register(source, hook, listener) {
+        const h = new Hook(source, hook, listener);
+        this.getRegistered(hook).push(h);
+    }
+    fire(hook, args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const registeredHooks = this.hooks.get(hook) || [];
+            return Promise.all(registeredHooks.map((h) => h.fire(args)));
+        });
+    }
+    getSources(hook) {
+        return [...new Set(this.getRegistered(hook).map(h => h.source))];
+    }
+    hasSources(hook, sources) {
+        return sources.filter(s => this.getSources(hook).includes(s)).length > 0;
+    }
+    deleteSource(source) {
+        for (let [hookName, hooks] of this.hooks.entries()) {
+            this.hooks.set(hookName, hooks.filter((h) => h.source !== source));
+        }
+    }
+    getRegistered(hook) {
+        let registeredHooks = this.hooks.get(hook);
+        if (!registeredHooks) {
+            registeredHooks = [];
+            this.hooks.set(hook, registeredHooks);
+        }
+        return registeredHooks;
+    }
+}
+exports.HookEngine = HookEngine;

node_modules/@ionic/cli-utils/lib/http.d.ts

@@ -0,0 +1,30 @@
+import * as superagentType from 'superagent';
+import { APIResponse, APIResponseError, APIResponseSuccess, HttpMethod, IClient, IPaginator, Response, SuperAgentError } from '../definitions';
+import { FatalException } from './errors';
+export declare const ERROR_UNKNOWN_CONTENT_TYPE = "UNKNOWN_CONTENT_TYPE";
+export declare const ERROR_UNKNOWN_RESPONSE_FORMAT = "UNKNOWN_RESPONSE_FORMAT";
+export declare function getGlobalProxy(): [string, string] | [undefined, undefined];
+export declare function createRequest(method: string, url: string): superagentType.SuperAgentRequest;
+export declare class Client implements IClient {
+    host: string;
+    constructor(host: string);
+    make(method: HttpMethod, path: string): superagentType.SuperAgentRequest;
+    do(req: superagentType.SuperAgentRequest): Promise<APIResponseSuccess>;
+    paginate<T extends Response<Object[]>>(reqgen: () => superagentType.SuperAgentRequest, guard: (res: APIResponseSuccess) => res is T): Paginator<T>;
+}
+export declare class Paginator<T extends Response<Object[]>> implements IPaginator<T> {
+    protected client: IClient;
+    protected reqgen: () => superagentType.SuperAgentRequest;
+    protected guard: (res: APIResponseSuccess) => res is T;
+    protected previousReq?: superagentType.SuperAgentRequest;
+    protected done: boolean;
+    constructor(client: IClient, reqgen: () => superagentType.SuperAgentRequest, guard: (res: APIResponseSuccess) => res is T);
+    next(): IteratorResult<Promise<T>>;
+    [Symbol.iterator](): this;
+}
+export declare function transformAPIResponse(r: superagentType.Response): APIResponse;
+export declare function createFatalAPIFormat(req: superagentType.SuperAgentRequest, res: APIResponse): FatalException;
+export declare function formatSuperAgentError(e: SuperAgentError): string;
+export declare function formatAPIResponse(req: superagentType.SuperAgentRequest, r: APIResponse): string;
+export declare function formatAPISuccess(req: superagentType.SuperAgentRequest, r: APIResponseSuccess): string;
+export declare function formatAPIError(req: superagentType.SuperAgentRequest, r: APIResponseError): string;

node_modules/@ionic/cli-utils/lib/http.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const util = require("util");
+const chalk = require("chalk");
+const guards_1 = require("../guards");
+const modules_1 = require("./modules");
+const errors_1 = require("./errors");
+const FORMAT_ERROR_BODY_MAX_LENGTH = 1000;
+const CONTENT_TYPE_JSON = 'application/json';
+exports.ERROR_UNKNOWN_CONTENT_TYPE = 'UNKNOWN_CONTENT_TYPE';
+exports.ERROR_UNKNOWN_RESPONSE_FORMAT = 'UNKNOWN_RESPONSE_FORMAT';
+function getGlobalProxy() {
+    const envvars = ['IONIC_HTTP_PROXY', 'HTTPS_PROXY', 'HTTP_PROXY', 'PROXY', 'https_proxy', 'http_proxy', 'proxy'];
+    for (let envvar of envvars) {
+        if (process.env[envvar]) {
+            return [process.env[envvar], envvar];
+        }
+    }
+    return [undefined, undefined];
+}
+exports.getGlobalProxy = getGlobalProxy;
+function createRequest(method, url) {
+    const [proxy,] = getGlobalProxy();
+    const superagent = modules_1.load('superagent');
+    let req = superagent(method, url);
+    if (proxy && req.proxy) {
+        req = req.proxy(proxy);
+    }
+    return req;
+}
+exports.createRequest = createRequest;
+class Client {
+    constructor(host) {
+        this.host = host;
+    }
+    make(method, path) {
+        return createRequest(method, `${this.host}${path}`)
+            .set('Content-Type', CONTENT_TYPE_JSON)
+            .set('Accept', CONTENT_TYPE_JSON);
+    }
+    do(req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const res = yield req;
+            const r = transformAPIResponse(res);
+            if (guards_1.isAPIResponseError(r)) {
+                throw new errors_1.FatalException('API request was successful, but the response output format was that of an error.\n'
+                    + formatAPIError(req, r));
+            }
+            return r;
+        });
+    }
+    paginate(reqgen, guard) {
+        return new Paginator(this, reqgen, guard);
+    }
+}
+exports.Client = Client;
+class Paginator {
+    constructor(client, reqgen, guard) {
+        this.client = client;
+        this.reqgen = reqgen;
+        this.guard = guard;
+        this.done = false;
+    }
+    next() {
+        if (this.done) {
+            return { done: true }; // TODO: why can't I exclude value?
+        }
+        return {
+            done: false,
+            value: (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const req = this.reqgen();
+                if (!this.previousReq) {
+                    this.previousReq = req;
+                }
+                const page = this.previousReq.qs.page && !isNaN(Number(this.previousReq.qs.page)) ? this.previousReq.qs.page + 1 : 1;
+                const pageSize = this.previousReq.qs.page_size && !isNaN(Number(this.previousReq.qs.page_size)) ? this.previousReq.qs.page_size : 25;
+                req.query({ page, 'page_size': pageSize });
+                const res = yield this.client.do(req);
+                if (!this.guard(res)) {
+                    throw createFatalAPIFormat(req, res);
+                }
+                if (res.data.length === 0 || res.data.length < pageSize) {
+                    this.done = true;
+                }
+                this.previousReq = req;
+                return res;
+            }))(),
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+exports.Paginator = Paginator;
+function transformAPIResponse(r) {
+    if (r.status === 204) {
+        r.body = { data: null, meta: { status: 204, version: '', request_id: '' } };
+    }
+    if (r.status !== 204 && r.type !== CONTENT_TYPE_JSON) {
+        throw exports.ERROR_UNKNOWN_CONTENT_TYPE;
+    }
+    let j = r.body;
+    if (!j.meta) {
+        throw exports.ERROR_UNKNOWN_RESPONSE_FORMAT;
+    }
+    return j;
+}
+exports.transformAPIResponse = transformAPIResponse;
+function createFatalAPIFormat(req, res) {
+    return new errors_1.FatalException('API request was successful, but the response format was unrecognized.\n'
+        + formatAPIResponse(req, res));
+}
+exports.createFatalAPIFormat = createFatalAPIFormat;
+function formatSuperAgentError(e) {
+    const res = e.response;
+    const req = res.request;
+    const statusCode = e.response.status;
+    let f = '';
+    try {
+        const r = transformAPIResponse(res);
+        f += formatAPIResponse(req, r);
+    }
+    catch (e) {
+        f += `HTTP Error ${statusCode}: ${req.method.toUpperCase()} ${req.url}\n`;
+        // TODO: do this only if verbose?
+        f += '\n' + res.text ? res.text.substring(0, FORMAT_ERROR_BODY_MAX_LENGTH) : '<no buffered body>';
+        if (res.text && res.text.length > FORMAT_ERROR_BODY_MAX_LENGTH) {
+            f += ` ...\n\n[ truncated ${res.text.length - FORMAT_ERROR_BODY_MAX_LENGTH} characters ]`;
+        }
+    }
+    return chalk.bold(chalk.red(f));
+}
+exports.formatSuperAgentError = formatSuperAgentError;
+function formatAPIResponse(req, r) {
+    if (guards_1.isAPIResponseSuccess(r)) {
+        return formatAPISuccess(req, r);
+    }
+    else {
+        return formatAPIError(req, r);
+    }
+}
+exports.formatAPIResponse = formatAPIResponse;
+function formatAPISuccess(req, r) {
+    return `Request: ${req.method} ${req.url}\n`
+        + `Response: ${r.meta.status}\n`
+        + `Body: \n${util.inspect(r.data, { colors: chalk.enabled })}`;
+}
+exports.formatAPISuccess = formatAPISuccess;
+function formatAPIError(req, r) {
+    return `Request: ${req.method} ${req.url}\n`
+        + `Response: ${r.meta.status}\n`
+        + `Body: \n${util.inspect(r.error, { colors: chalk.enabled })}`;
+}
+exports.formatAPIError = formatAPIError;

node_modules/@ionic/cli-utils/lib/login.d.ts

@@ -0,0 +1,2 @@
+import { IonicEnvironment } from '../definitions';
+export declare function promptToLogin(env: IonicEnvironment): Promise<void>;

node_modules/@ionic/cli-utils/lib/login.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const validators_1 = require("./validators");
+function promptToLogin(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        env.log.msg(`Log into your Ionic account\nIf you don't have one yet, create yours by running: ${chalk.green(`ionic signup`)}\n`);
+        const email = yield env.prompt({
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            validate: v => validators_1.validators.email(v),
+        });
+        const password = yield env.prompt({
+            type: 'password',
+            name: 'password',
+            message: 'Password:'
+        });
+        yield env.session.login(email, password);
+    });
+}
+exports.promptToLogin = promptToLogin;

node_modules/@ionic/cli-utils/lib/modules.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import * as LeekType from 'leek';
+import * as archiverType from 'archiver';
+import * as crossSpawnType from 'cross-spawn';
+import * as dargsType from 'dargs';
+import * as lodashType from 'lodash';
+import * as semverType from 'semver';
+import * as sliceAnsiType from 'slice-ansi';
+import * as stripAnsiType from 'strip-ansi';
+import * as superagentType from 'superagent';
+import * as uuidType from 'uuid';
+import * as wrapAnsiType from 'wrap-ansi';
+export declare function load(modulePath: 'archiver'): typeof archiverType;
+export declare function load(modulePath: 'cross-spawn'): typeof crossSpawnType;
+export declare function load(modulePath: 'dargs'): typeof dargsType;
+export declare function load(modulePath: 'leek'): typeof LeekType;
+export declare function load(modulePath: 'lodash'): typeof lodashType;
+export declare function load(modulePath: 'semver'): typeof semverType;
+export declare function load(modulePath: 'slice-ansi'): typeof sliceAnsiType;
+export declare function load(modulePath: 'strip-ansi'): typeof stripAnsiType;
+export declare function load(modulePath: 'superagent'): typeof superagentType;
+export declare function load(modulePath: 'uuid'): typeof uuidType;
+export declare function load(modulePath: 'wrap-ansi'): typeof wrapAnsiType;

node_modules/@ionic/cli-utils/lib/modules.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function load(modulePath) {
+    return require(modulePath);
+}
+exports.load = load;

node_modules/@ionic/cli-utils/lib/package.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { IClient, PackageBuild, PackageProjectRequest } from '../definitions';
+export declare class PackageClient {
+    protected appUserToken: string;
+    protected client: IClient;
+    constructor(appUserToken: string, client: IClient);
+    getBuild(id: number, {fields}: {
+        fields?: string[];
+    }): Promise<PackageBuild>;
+    getBuilds({page, pageSize}: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<PackageBuild[]>;
+    queueBuild({platform, mode, zipUrl, projectId, profileTag}: {
+        platform: PackageBuild['platform'];
+        mode: PackageBuild['mode'];
+        zipUrl: string;
+        projectId: number;
+        profileTag?: string;
+    }): Promise<PackageBuild>;
+    requestProjectUpload(): Promise<PackageProjectRequest>;
+    uploadProject(project: PackageProjectRequest, zip: NodeJS.ReadableStream, {progress}: {
+        progress?: (loaded: number, total: number) => void;
+    }): Promise<void>;
+    downloadBuild(build: PackageBuild, dest: NodeJS.WritableStream, {progress}: {
+        progress?: (loaded: number, total: number) => void;
+    }): Promise<void>;
+    colorStatus(s: PackageBuild['status']): string;
+    formatFilename(build: PackageBuild): string;
+    formatPlatform(p: PackageBuild['platform'] | string): string;
+    formatBuildValues(build: PackageBuild): {
+        [P in keyof PackageBuild]?: string;
+    };
+}

node_modules/@ionic/cli-utils/lib/package.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const guards_1 = require("../guards");
+const http_1 = require("./http");
+const aws_1 = require("./utils/aws");
+class PackageClient {
+    constructor(appUserToken, client) {
+        this.appUserToken = appUserToken;
+        this.client = client;
+    }
+    getBuild(id, { fields = [] }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (fields.indexOf('url') === -1) {
+                fields.push('url');
+            }
+            const req = this.client.make('GET', `/package/builds/${id}`)
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .query({ fields })
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isPackageBuildResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    getBuilds({ page = 1, pageSize = 25 }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('GET', '/package/builds')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .query({ page, 'page_size': pageSize, })
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isPackageBuildsResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    queueBuild({ platform, mode, zipUrl, projectId, profileTag }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('POST', '/package/builds')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send({
+                platform,
+                build_mode: mode,
+                zip_url: zipUrl,
+                project_id: projectId,
+                security_profile_tag: profileTag,
+            });
+            const res = yield this.client.do(req);
+            if (!guards_1.isPackageBuildResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    requestProjectUpload() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('POST', '/package/projects')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .send({});
+            const res = yield this.client.do(req);
+            if (!guards_1.isPackageProjectRequestResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    uploadProject(project, zip, { progress }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return aws_1.s3SignedUpload(project.presigned_post, zip, { progress });
+        });
+    }
+    downloadBuild(build, dest, { progress }) {
+        return new Promise((resolve, reject) => {
+            if (build.status !== 'SUCCESS') {
+                return reject(new Error(`Build must be 'SUCCESS', not '${build.status}'.`));
+            }
+            if (!build.url) {
+                return reject(new Error('Build must have URL.'));
+            }
+            dest.on('error', (err) => {
+                reject(err);
+            });
+            dest.on('close', () => {
+                resolve();
+            });
+            http_1.createRequest('get', build.url)
+                .on('response', (res) => {
+                if (progress) {
+                    let loaded = 0;
+                    const total = Number(res.headers['content-length']);
+                    res.on('data', (chunk) => {
+                        loaded += chunk.length;
+                        progress(loaded, total);
+                    });
+                }
+            })
+                .on('error', (err) => {
+                reject(err);
+            })
+                .pipe(dest);
+        });
+    }
+    colorStatus(s) {
+        switch (s) {
+            case 'SUCCESS':
+                return chalk.green(s);
+            case 'FAILED':
+                return chalk.red(s);
+        }
+        return s;
+    }
+    formatFilename(build) {
+        const extension = build.platform === 'android' ? 'apk' : 'ipa';
+        return `${build.name}.${extension}`;
+    }
+    formatPlatform(p) {
+        switch (p) {
+            case 'ios':
+                return 'iOS';
+            case 'android':
+                return 'Android';
+        }
+        return p;
+    }
+    formatBuildValues(build) {
+        return {
+            id: String(build.id),
+            status: this.colorStatus(build.status),
+            platform: this.formatPlatform(build.platform),
+            mode: build.mode,
+            security_profile_tag: build.security_profile_tag || '',
+            created: new Date(build.created).toISOString(),
+            completed: build.completed ? new Date(build.completed).toISOString() : '',
+        };
+    }
+}
+exports.PackageClient = PackageClient;

node_modules/@ionic/cli-utils/lib/plugins.d.ts

@@ -0,0 +1,34 @@
+import { DistTag, IonicEnvironment, Plugin } from '../definitions';
+import { PkgManagerOptions } from './utils/npm';
+export declare const KNOWN_COMMAND_PLUGINS: string[];
+export declare const KNOWN_GLOBAL_PLUGINS: string[];
+export declare const KNOWN_PROJECT_PLUGINS: string[];
+export declare const ORG_PREFIX = "@ionic";
+export declare const PLUGIN_PREFIX = "cli-plugin-";
+export declare const ERROR_PLUGIN_NOT_INSTALLED = "PLUGIN_NOT_INSTALLED";
+export declare const ERROR_PLUGIN_NOT_FOUND = "PLUGIN_NOT_FOUND";
+export declare const ERROR_PLUGIN_INVALID = "PLUGIN_INVALID";
+export declare function formatFullPluginName(name: string): string;
+export declare function promptToInstallProjectPlugin(env: IonicEnvironment, {message}: {
+    message?: string;
+}): Promise<Plugin | undefined>;
+export declare function promptToInstallPlugin(env: IonicEnvironment, pluginName: string, {message, global, reinstall}: {
+    message?: string;
+    global?: boolean;
+    reinstall?: boolean;
+}): Promise<Plugin | undefined>;
+export declare function registerPlugin(env: IonicEnvironment, plugin: Plugin): void;
+export declare function unregisterPlugin(env: IonicEnvironment, plugin: Plugin): void;
+export declare function loadPlugins(env: IonicEnvironment): Promise<void>;
+export declare function validatePlugins(env: IonicEnvironment): void;
+export interface LoadPluginOptions {
+    message?: string;
+    askToInstall?: boolean;
+    reinstall?: boolean;
+    global?: boolean;
+}
+export declare function loadPlugin(env: IonicEnvironment, pluginName: string, {message, askToInstall, reinstall, global}: LoadPluginOptions): Promise<Plugin>;
+export declare function pluginHasUpdate(currentVersion: string, latestVersion: string): Promise<boolean>;
+export declare function checkForUpdates(env: IonicEnvironment): Promise<string[]>;
+export declare function pkgInstallPluginArgs(env: IonicEnvironment, name: string, options?: PkgManagerOptions): Promise<string[]>;
+export declare function determineDistTag(version: string): DistTag;

node_modules/@ionic/cli-utils/lib/plugins.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const guards_1 = require("../guards");
+const errors_1 = require("./errors");
+const format_1 = require("./utils/format");
+const fs_1 = require("./utils/fs");
+const http_1 = require("./http");
+const npm_1 = require("./utils/npm");
+exports.KNOWN_COMMAND_PLUGINS = ['cordova'];
+exports.KNOWN_GLOBAL_PLUGINS = ['proxy'];
+exports.KNOWN_PROJECT_PLUGINS = ['ionic1', 'ionic-angular'];
+exports.ORG_PREFIX = '@ionic';
+exports.PLUGIN_PREFIX = 'cli-plugin-';
+exports.ERROR_PLUGIN_NOT_INSTALLED = 'PLUGIN_NOT_INSTALLED';
+exports.ERROR_PLUGIN_NOT_FOUND = 'PLUGIN_NOT_FOUND';
+exports.ERROR_PLUGIN_INVALID = 'PLUGIN_INVALID';
+function formatFullPluginName(name) {
+    return `${exports.ORG_PREFIX}/${exports.PLUGIN_PREFIX}${name}`;
+}
+exports.formatFullPluginName = formatFullPluginName;
+function promptToInstallProjectPlugin(env, { message }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const project = yield env.project.load();
+        const projectPlugin = formatFullPluginName(project.type);
+        if (!message) {
+            message = `Looks like this is an ${env.project.formatType(project.type)} project, would you like to install ${chalk.green(projectPlugin)} and continue?`;
+        }
+        return yield promptToInstallPlugin(env, projectPlugin, { message });
+    });
+}
+exports.promptToInstallProjectPlugin = promptToInstallProjectPlugin;
+function promptToInstallPlugin(env, pluginName, { message, global = false, reinstall = false }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!global && !env.project.directory) {
+            return;
+        }
+        try {
+            return yield loadPlugin(env, pluginName, {
+                askToInstall: true,
+                global,
+                reinstall,
+                message,
+            });
+        }
+        catch (e) {
+            if (e !== exports.ERROR_PLUGIN_NOT_INSTALLED) {
+                throw e;
+            }
+        }
+    });
+}
+exports.promptToInstallPlugin = promptToInstallPlugin;
+function registerPlugin(env, plugin) {
+    const ns = plugin.namespace;
+    if (ns) {
+        env.namespace.namespaces.set(ns.name, () => ns);
+    }
+    if (plugin.registerHooks) {
+        plugin.registerHooks(env.hooks);
+    }
+    env.plugins[plugin.name] = plugin;
+}
+exports.registerPlugin = registerPlugin;
+function unregisterPlugin(env, plugin) {
+    if (plugin.namespace) {
+        env.namespace.namespaces.delete(plugin.namespace.name);
+    }
+    env.hooks.deleteSource(plugin.name);
+    delete env.plugins[plugin.name];
+}
+exports.unregisterPlugin = unregisterPlugin;
+function loadPlugins(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // GLOBAL PLUGINS
+        const global = !env.meta || !env.meta.local;
+        const globalPluginPkgs = exports.KNOWN_GLOBAL_PLUGINS.map(formatFullPluginName);
+        const globalPluginPromises = globalPluginPkgs.map((pkgName) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield loadPlugin(env, pkgName, { askToInstall: false, global });
+            }
+            catch (e) {
+                if (e !== exports.ERROR_PLUGIN_NOT_INSTALLED) {
+                    throw e;
+                }
+            }
+        }));
+        for (let p of globalPluginPromises) {
+            const plugin = yield p;
+            if (plugin) {
+                registerPlugin(env, plugin);
+            }
+        }
+        const [, proxyVar] = http_1.getGlobalProxy();
+        if (!env.project.directory) {
+            return;
+        }
+        const project = yield env.project.load();
+        // LOCAL PLUGINS
+        const ionicModulePath = path.join(env.project.directory, 'node_modules', 'ionic');
+        const gulpFilePath = path.join(env.project.directory, project.gulpFile || 'gulpfile.js');
+        const mPath = path.join(env.project.directory, 'node_modules', '@ionic');
+        const [ionicModuleExists, gulpFileExists, ionicModules] = yield Promise.all([
+            fs_1.pathExists(ionicModulePath),
+            fs_1.pathExists(gulpFilePath),
+            fs_1.readDir(mPath),
+        ]);
+        if (!ionicModuleExists) {
+            // TODO: remove "starting with 3.6"
+            env.log.warn(chalk.yellow(chalk.bold('No local CLI detected.\n') +
+                'Starting with CLI 3.6, the CLI must be installed locally to use local CLI plugins.\n'));
+            const p = yield promptToInstallPlugin(env, 'ionic', {
+                message: 'Install now?',
+            });
+            if (p) {
+                env.log.ok('Installed Ionic CLI locally!');
+                env.log.nl();
+                throw new errors_1.FatalException(`${chalk.bold('Please re-run your command.')}`, 0);
+            }
+            else {
+                env.log.warn('Not loading local CLI plugins in global mode. CLI functionality may be limited.');
+                return;
+            }
+        }
+        if (proxyVar) {
+            const proxyPluginPkg = formatFullPluginName('proxy');
+            env.log.debug(() => `Detected ${chalk.green(proxyVar)} in environment`);
+            if (!(proxyPluginPkg in env.plugins)) {
+                const meta = env.plugins.ionic.meta;
+                if (!meta) {
+                    throw new errors_1.FatalException(`${chalk.green('ionic')} missing meta information`);
+                }
+                const canInstall = yield fs_1.pathAccessible(meta.filePath, fs.constants.W_OK);
+                const proxyInstallArgs = yield npm_1.pkgManagerArgs(env, { pkg: proxyPluginPkg, global });
+                const installMsg = `Detected ${chalk.green(proxyVar)} in environment, but to proxy CLI requests, you'll need ${chalk.green(proxyPluginPkg)} installed.`;
+                if (canInstall) {
+                    const p = yield promptToInstallPlugin(env, proxyPluginPkg, {
+                        message: `${installMsg} Install now?`,
+                        reinstall: true,
+                        global,
+                    });
+                    if (p) {
+                        registerPlugin(env, p);
+                    }
+                }
+                else {
+                    env.log.warn(`${installMsg}\nYou can install it manually:\n\n${chalk.green(proxyInstallArgs.join(' '))}\n`);
+                }
+            }
+        }
+        const plugins = [];
+        const pluginPkgs = ionicModules
+            .filter(pkgName => pkgName.indexOf(exports.PLUGIN_PREFIX) === 0)
+            .map(pkgName => `${exports.ORG_PREFIX}/${pkgName}`)
+            .filter(pkgName => !exports.KNOWN_GLOBAL_PLUGINS.map(formatFullPluginName).includes(pkgName)); // already loaded these in global section above
+        const gulpPluginPkg = formatFullPluginName('gulp');
+        if (gulpFileExists) {
+            env.log.debug(() => `Detected ${chalk.green(format_1.prettyPath(gulpFilePath))} in project directory`);
+            if (!pluginPkgs.includes(gulpPluginPkg)) {
+                const installMsg = `Detected ${chalk.green(format_1.prettyPath(gulpFilePath))} in project directory, but to integrate gulp with the CLI, you'll need to install ${chalk.green(gulpPluginPkg)}.`;
+                const p = yield promptToInstallPlugin(env, gulpPluginPkg, {
+                    message: `${installMsg} Install now?`,
+                    reinstall: true,
+                });
+                if (p) {
+                    plugins.push(p);
+                }
+            }
+        }
+        const pluginPromises = pluginPkgs.map(pkgName => {
+            return loadPlugin(env, pkgName, { askToInstall: false });
+        });
+        for (let p of pluginPromises) {
+            const plugin = yield p;
+            plugins.push(plugin);
+        }
+        // TODO: remember the responses of the requests below
+        const projectPlugin = formatFullPluginName(project.type);
+        if (!pluginPkgs.includes(projectPlugin)) {
+            const plugin = yield promptToInstallProjectPlugin(env, {});
+            if (plugin) {
+                plugins.push(plugin);
+            }
+        }
+        for (let plugin of plugins) {
+            registerPlugin(env, plugin);
+        }
+        validatePlugins(env);
+    });
+}
+exports.loadPlugins = loadPlugins;
+function validatePlugins(env) {
+    const projectPlugins = new Set(exports.KNOWN_PROJECT_PLUGINS.map(formatFullPluginName));
+    const installedPlugins = new Set(Object.keys(env.plugins));
+    const installedProjectPlugins = new Set([...projectPlugins].filter(p => installedPlugins.has(p)));
+    if (installedProjectPlugins.size === 0) {
+        env.log.warn('You have no CLI project plugins installed. CLI functionality may be limited.');
+    }
+    else if (installedProjectPlugins.size > 1) {
+        env.log.warn(`You have multiple CLI project plugins installed (${[...installedProjectPlugins].map(p => chalk.green(p)).join(', ')}). ${chalk.bold('Please make sure you have only one installed.')}`);
+    }
+}
+exports.validatePlugins = validatePlugins;
+function loadPlugin(env, pluginName, { message, askToInstall = true, reinstall = false, global = false }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const mPath = global ? pluginName : path.join(env.project.directory, 'node_modules', ...pluginName.split('/'));
+        let mResolvedPath;
+        let m;
+        if (!message) {
+            message = `The plugin ${chalk.green(pluginName)} is not installed. Would you like to install it and continue?`;
+        }
+        env.log.debug(() => `Loading ${global ? 'global' : 'local'} plugin ${chalk.green(pluginName)}`);
+        try {
+            mResolvedPath = require.resolve(mPath);
+            delete require.cache[mResolvedPath];
+            m = require(mResolvedPath);
+        }
+        catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+            if (!askToInstall) {
+                env.log.debug(() => `Throwing ${chalk.red(exports.ERROR_PLUGIN_NOT_INSTALLED)} for ${global ? 'global' : 'local'} ${chalk.green(pluginName)}`);
+                throw exports.ERROR_PLUGIN_NOT_INSTALLED;
+            }
+        }
+        if (!m || reinstall) {
+            const confirm = yield env.prompt({
+                type: 'confirm',
+                name: 'confirm',
+                message,
+            });
+            if (confirm) {
+                const [installer, ...installerArgs] = yield pkgInstallPluginArgs(env, pluginName, { global });
+                yield env.shell.run(installer, installerArgs, {});
+                m = yield loadPlugin(env, pluginName, { askToInstall: false, global });
+                mResolvedPath = require.resolve(mPath);
+            }
+            else {
+                throw exports.ERROR_PLUGIN_NOT_INSTALLED;
+            }
+        }
+        if (!guards_1.isPlugin(m) || !mResolvedPath) {
+            env.log.debug(() => `Throwing ${chalk.red(exports.ERROR_PLUGIN_INVALID)} for ${global ? 'global' : 'local'} ${chalk.green(pluginName)}`);
+            throw exports.ERROR_PLUGIN_INVALID;
+        }
+        m.meta = {
+            filePath: mResolvedPath,
+        };
+        return m;
+    });
+}
+exports.loadPlugin = loadPlugin;
+function hydratePlugin(env, plugin) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        env.log.debug(() => `Getting plugin info for ${chalk.green(plugin.name)}`);
+        const currentVersion = plugin.version;
+        const latestVersion = yield getLatestPluginVersion(env, plugin);
+        const distTag = determineDistTag(currentVersion);
+        const meta = plugin.meta;
+        if (!meta) {
+            throw new errors_1.FatalException(`${chalk.green(plugin.name)} missing meta information`);
+        }
+        return Object.assign({}, plugin, { meta,
+            distTag,
+            currentVersion,
+            latestVersion, updateAvailable: yield pluginHasUpdate(currentVersion, latestVersion) });
+    });
+}
+function pluginHasUpdate(currentVersion, latestVersion) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const semver = yield Promise.resolve().then(function () { return require('semver'); });
+        const distTag = determineDistTag(currentVersion);
+        return semver.gt(latestVersion, currentVersion) || ('canary' === distTag && latestVersion !== currentVersion);
+    });
+}
+exports.pluginHasUpdate = pluginHasUpdate;
+function facilitateIonicUpdate(env, ionicPlugin) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const global = !env.meta || !env.meta.local;
+        const ionicInstallArgs = yield pkgInstallPluginArgs(env, 'ionic', { global });
+        const updateMsg = `The Ionic CLI ${global ? '' : '(local version) '}has an update available (${chalk.green(ionicPlugin.currentVersion)} => ${chalk.green(ionicPlugin.latestVersion)})!`;
+        const canInstall = global ? yield fs_1.pathAccessible(ionicPlugin.meta.filePath, fs.constants.W_OK) : true;
+        if (canInstall) {
+            const confirm = yield env.prompt({
+                name: 'confirm',
+                type: 'confirm',
+                message: `${updateMsg} Would you like to install it?`,
+            });
+            if (confirm) {
+                const [installer, ...installerArgs] = ionicInstallArgs;
+                yield env.shell.run(installer, installerArgs, {});
+                const revertArgs = yield npm_1.pkgManagerArgs(env, { pkg: `ionic@${ionicPlugin.currentVersion}`, global });
+                env.log.nl();
+                env.log.ok(`Updated Ionic CLI to ${chalk.green(ionicPlugin.latestVersion)}! 🎉`);
+                env.log.nl();
+                env.log.msg(chalk.bold('Please re-run your command.'));
+                env.log.nl();
+                throw new errors_1.FatalException(`${chalk.bold('Note')}: You can downgrade to your old version by running: ${chalk.green(revertArgs.join(' '))}`, 0);
+            }
+            else {
+                env.log.info(`Not automatically updating your CLI. You can update manually:\n\n${chalk.green(ionicInstallArgs.join(' '))}\n`);
+            }
+        }
+        else {
+            env.log.info(updateMsg);
+            env.log.nl();
+            env.log.warn(`No write permissions for ${global ? 'global' : 'local'} ${chalk.bold('node_modules')}--automatic CLI updates are disabled.\n` +
+                `To fix, see ${chalk.bold('https://docs.npmjs.com/getting-started/fixing-npm-permissions')}\n\n` +
+                `Or, install the CLI update manually:\n\n${chalk.green(ionicInstallArgs.join(' '))}\n`);
+        }
+    });
+}
+function facilitatePluginUpdate(env, ionicPlugin, plugin) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const global = !env.meta || !env.meta.local;
+        const pluginInstallArgs = yield pkgInstallPluginArgs(env, plugin.name, { global });
+        const startMsg = `${global ? 'Global' : 'Local'} plugin ${chalk.green(plugin.name)}`;
+        const updateMsg = `${startMsg} has an update available (${chalk.green(plugin.currentVersion)} => ${chalk.green(plugin.latestVersion)})!`;
+        const canInstall = global ? yield fs_1.pathAccessible(plugin.meta.filePath, fs.constants.W_OK) : true;
+        if (canInstall) {
+            const message = ionicPlugin.distTag === plugin.distTag ?
+                `${updateMsg} Would you like to install it?` :
+                `${startMsg} has a different dist-tag (${chalk.green('@' + plugin.distTag)}) than the Ionic CLI (${chalk.green('@' + ionicPlugin.distTag)}). Would you like to install the appropriate plugin version?`;
+            const okmessage = ionicPlugin.distTag === plugin.distTag ?
+                `Updated ${chalk.green(plugin.name)} to ${chalk.green(plugin.latestVersion)}! 🎉` :
+                `Installed ${chalk.green(plugin.name + '@' + ionicPlugin.distTag)}`;
+            const p = yield promptToInstallPlugin(env, plugin.name, {
+                message,
+                reinstall: true,
+                global,
+            });
+            if (p) {
+                unregisterPlugin(env, plugin);
+                registerPlugin(env, p);
+                env.log.ok(okmessage);
+                return true;
+            }
+            env.log.info(`Not automatically updating ${chalk.green(plugin.name)}. You can update manually:\n\n${chalk.green(pluginInstallArgs.join(' '))}\n`);
+        }
+        else {
+            env.log.info(updateMsg);
+            env.log.nl();
+            env.log.warn(`No write permissions for ${global ? 'global' : 'local'}${chalk.bold('node_modules')}--automatic plugin updates are disabled.\n` +
+                `To fix, see ${chalk.bold('https://docs.npmjs.com/getting-started/fixing-npm-permissions')}\n`);
+        }
+        return false;
+    });
+}
+function checkForUpdates(env) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const [config,] = yield Promise.all([env.config.load(), env.daemon.load()]);
+        if (!config.daemon.updates) {
+            return [];
+        }
+        const allPlugins = yield Promise.all(Object.keys(env.plugins).map(n => hydratePlugin(env, env.plugins[n])));
+        yield env.daemon.save();
+        const ionicPlugin = allPlugins.find(p => p.name === 'ionic');
+        if (!ionicPlugin) {
+            throw new errors_1.FatalException('Ionic plugin not initialized.');
+        }
+        if (ionicPlugin.updateAvailable) {
+            yield facilitateIonicUpdate(env, ionicPlugin);
+        }
+        const plugins = allPlugins.filter(p => p.name !== 'ionic');
+        const updates = [];
+        for (let plugin of plugins) {
+            if (plugin.updateAvailable || ionicPlugin.distTag !== plugin.distTag) {
+                const installed = yield facilitatePluginUpdate(env, ionicPlugin, plugin);
+                if (installed) {
+                    updates.push(plugin.name);
+                }
+            }
+        }
+        if (updates.length > 0) {
+            const [installer, ...dedupeArgs] = yield npm_1.pkgManagerArgs(env, { command: 'dedupe' });
+            if (dedupeArgs.length > 0) {
+                try {
+                    yield env.shell.run(installer, dedupeArgs, { fatalOnError: false });
+                }
+                catch (e) {
+                    env.log.warn('Error while deduping npm dependencies. Attempting to continue...');
+                }
+            }
+        }
+        return updates;
+    });
+}
+exports.checkForUpdates = checkForUpdates;
+function getLatestPluginVersion(env, plugin) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const distTag = determineDistTag(plugin.version);
+        if (distTag === 'local') {
+            return plugin.version;
+        }
+        env.log.debug(() => `Checking for latest plugin version of ${chalk.green(plugin.name + '@' + distTag)}.`);
+        const daemon = yield env.daemon.load();
+        if (typeof daemon.latestVersions[distTag] === 'object') {
+            if (daemon.latestVersions[distTag][plugin.name]) {
+                return daemon.latestVersions[distTag][plugin.name];
+            }
+        }
+        else {
+            env.daemon.populateDistTag(distTag);
+        }
+        let latestVersion = yield npm_1.pkgLatestVersion(env, plugin.name, distTag);
+        if (!latestVersion) {
+            latestVersion = plugin.version;
+        }
+        latestVersion = latestVersion.trim();
+        env.log.debug(`Latest version of ${chalk.green(plugin.name + '@' + distTag)} is ${latestVersion}.`);
+        daemon.latestVersions[distTag][plugin.name] = latestVersion;
+        return latestVersion;
+    });
+}
+function pkgInstallPluginArgs(env, name, options = {}) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const releaseChannelName = determineDistTag(env.plugins.ionic.version);
+        let pluginInstallVersion = `${name}@${releaseChannelName}`;
+        if (releaseChannelName === 'local') {
+            options.link = true;
+            pluginInstallVersion = name;
+        }
+        options.pkg = pluginInstallVersion;
+        options.saveDev = true;
+        return npm_1.pkgManagerArgs(env, options);
+    });
+}
+exports.pkgInstallPluginArgs = pkgInstallPluginArgs;
+function determineDistTag(version) {
+    if (version.includes('-local')) {
+        return 'local';
+    }
+    if (version.includes('-alpha')) {
+        return 'canary';
+    }
+    if (version.includes('-beta') || version.includes('-rc')) {
+        return 'beta';
+    }
+    return 'latest';
+}
+exports.determineDistTag = determineDistTag;

node_modules/@ionic/cli-utils/lib/project.d.ts

@@ -0,0 +1,17 @@
+import { BowerJson, IProject, PackageJson, ProjectFile, ProjectType } from '../definitions';
+import { BaseConfig } from './config';
+export declare const PROJECT_FILE = "ionic.config.json";
+export declare const PROJECT_FILE_LEGACY = "ionic.project";
+export declare const PROJECT_TYPES: ProjectType[];
+export declare class Project extends BaseConfig<ProjectFile> implements IProject {
+    directory: string;
+    protected packageJsonFile?: PackageJson;
+    protected bowerJsonFile?: BowerJson;
+    loadAppId(): Promise<string>;
+    loadPackageJson(): Promise<PackageJson>;
+    loadBowerJson(): Promise<BowerJson>;
+    provideDefaults(o: any): Promise<any>;
+    determineType(): Promise<ProjectType>;
+    is(j: any): j is ProjectFile;
+    formatType(type: ProjectType): "Ionic Angular" | "Ionic 1";
+}

node_modules/@ionic/cli-utils/lib/project.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = require("path");
+const chalk = require("chalk");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+const fs_1 = require("./utils/fs");
+const npm_1 = require("./utils/npm");
+const format_1 = require("./utils/format");
+const modules_1 = require("./modules");
+exports.PROJECT_FILE = 'ionic.config.json';
+exports.PROJECT_FILE_LEGACY = 'ionic.project';
+exports.PROJECT_TYPES = ['ionic-angular', 'ionic1'];
+class Project extends config_1.BaseConfig {
+    loadAppId() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const p = yield this.load();
+            if (!p.app_id) {
+                throw new errors_1.FatalException(`Your project file (${chalk.bold(format_1.prettyPath(this.filePath))}) does not contain '${chalk.bold('app_id')}'. `
+                    + `Run ${chalk.green('ionic link')}.`);
+            }
+            return p.app_id;
+        });
+    }
+    loadPackageJson() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.packageJsonFile) {
+                const packageJsonPath = path.resolve(this.directory, 'package.json');
+                try {
+                    this.packageJsonFile = yield npm_1.readPackageJsonFile(packageJsonPath);
+                }
+                catch (e) {
+                    if (e === fs_1.ERROR_FILE_INVALID_JSON) {
+                        throw new errors_1.FatalException(`Could not parse ${chalk.bold('package.json')}. Is it a valid JSON file?`);
+                    }
+                    else if (e === npm_1.ERROR_INVALID_PACKAGE_JSON) {
+                        throw new errors_1.FatalException(`The ${chalk.bold('package.json')} file seems malformed.`);
+                    }
+                    throw e; // Probably file not found
+                }
+            }
+            return this.packageJsonFile;
+        });
+    }
+    loadBowerJson() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.bowerJsonFile) {
+                const bowerJsonPath = path.resolve(this.directory, 'bower.json');
+                try {
+                    this.bowerJsonFile = yield npm_1.readBowerJsonFile(bowerJsonPath);
+                }
+                catch (e) {
+                    if (e === fs_1.ERROR_FILE_INVALID_JSON) {
+                        throw new errors_1.FatalException(`Could not parse ${chalk.bold('bower.json')}. Is it a valid JSON file?`);
+                    }
+                    else if (e === npm_1.ERROR_INVALID_BOWER_JSON) {
+                        throw new errors_1.FatalException(`The ${chalk.bold('bower.json')} file seems malformed.`);
+                    }
+                    throw e; // Probably file not found
+                }
+            }
+            return this.bowerJsonFile;
+        });
+    }
+    provideDefaults(o) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const lodash = modules_1.load('lodash');
+            const results = lodash.cloneDeep(o);
+            if (!results.name) {
+                results.name = '';
+            }
+            if (!results.app_id) {
+                results.app_id = '';
+            }
+            if (!results.type) {
+                results.type = yield this.determineType();
+            }
+            delete results.projectTypeId;
+            delete results.typescript;
+            delete results.v2;
+            return results;
+        });
+    }
+    determineType() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const packageJson = yield this.loadPackageJson();
+                if (packageJson.dependencies && typeof packageJson.dependencies['ionic-angular'] === 'string') {
+                    return 'ionic-angular';
+                }
+            }
+            catch (e) {
+                if (e.fatal) {
+                    throw e;
+                }
+            }
+            try {
+                const bowerJson = yield this.loadBowerJson();
+                if ((bowerJson.dependencies && typeof bowerJson.dependencies['ionic'] === 'string') || (bowerJson.devDependencies && typeof bowerJson.devDependencies['ionic'] === 'string')) {
+                    return 'ionic1';
+                }
+            }
+            catch (e) {
+                if (e.fatal) {
+                    throw e;
+                }
+            }
+            throw new errors_1.FatalException(`Could not determine project type (project config: ${chalk.bold(format_1.prettyPath(this.filePath))}).\n\n`
+                + `For ${this.formatType('ionic-angular')} projects, make sure 'ionic-angular' exists in the ${chalk.bold('dependencies')} attribute of ${chalk.bold('package.json')}.\n`
+                + `For ${this.formatType('ionic1')} projects, make sure 'ionic' exists in the ${chalk.bold('devDependencies')} attribute of ${chalk.bold('bower.json')}.\n\n`
+                + `Alternatively, set ${chalk.bold('type')} attribute in ${chalk.bold('ionic.config.json')} to one of: ${exports.PROJECT_TYPES.map(v => '\'' + v + '\'').join(', ')}\n`);
+        });
+    }
+    is(j) {
+        return j && typeof j.name === 'string' && typeof j.app_id === 'string';
+    }
+    formatType(type) {
+        if (type === 'ionic-angular') {
+            return 'Ionic Angular';
+        }
+        else if (type === 'ionic1') {
+            return 'Ionic 1';
+        }
+        return type;
+    }
+}
+exports.Project = Project;

node_modules/@ionic/cli-utils/lib/prompts.d.ts

@@ -0,0 +1,7 @@
+import { ConfigFile, IConfig, ILogger, PromptModule } from '../definitions';
+export declare function createPromptModule({interactive, confirm, log, config}: {
+    interactive: boolean;
+    confirm: boolean;
+    log: ILogger;
+    config: IConfig<ConfigFile>;
+}): Promise<PromptModule>;

node_modules/@ionic/cli-utils/lib/prompts.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+function createPromptModule({ interactive, confirm, log, config }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const inquirer = yield Promise.resolve().then(function () { return require('inquirer'); });
+        const inquirerPromptModule = inquirer.createPromptModule();
+        function createPrompter(question) {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (interactive === false) {
+                    if (typeof question.noninteractiveValue !== 'undefined') {
+                        return question.noninteractiveValue;
+                    }
+                    if (question.type === 'confirm') {
+                        if (confirm) {
+                            log.info(`${chalk.green('--confirm')}: ${chalk.dim(question.message)} ${chalk.cyan('Yes')}`);
+                            return true;
+                        }
+                        else {
+                            log.info(`${chalk.green('--no-confirm')}: ${chalk.dim(question.message)} ${chalk.cyan('No')}`);
+                            return false;
+                        }
+                    }
+                    return '';
+                }
+                const result = (yield inquirerPromptModule(question))[question.name];
+                if (typeof result !== 'string' && typeof result !== 'boolean') {
+                    return String(result);
+                }
+                return result;
+            });
+        }
+        return createPrompter;
+    });
+}
+exports.createPromptModule = createPromptModule;

node_modules/@ionic/cli-utils/lib/security.d.ts

@@ -0,0 +1,11 @@
+import { IClient, SecurityProfile } from '../definitions';
+export declare class SecurityClient {
+    protected appUserToken: string;
+    protected client: IClient;
+    constructor(appUserToken: string, client: IClient);
+    getProfile(tag: string): Promise<SecurityProfile>;
+    getProfiles({page, pageSize}: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<SecurityProfile[]>;
+}

node_modules/@ionic/cli-utils/lib/security.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const guards_1 = require("../guards");
+const http_1 = require("./http");
+class SecurityClient {
+    constructor(appUserToken, client) {
+        this.appUserToken = appUserToken;
+        this.client = client;
+    }
+    getProfile(tag) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('GET', `/security/profiles/${tag}`)
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .query({})
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isSecurityProfileResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+    getProfiles({ page = 1, pageSize = 25 }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('GET', '/security/profiles')
+                .set('Authorization', `Bearer ${this.appUserToken}`)
+                .query({ page, 'page_size': pageSize, })
+                .send();
+            const res = yield this.client.do(req);
+            if (!guards_1.isSecurityProfilesResponse(res)) {
+                throw http_1.createFatalAPIFormat(req, res);
+            }
+            return res.data;
+        });
+    }
+}
+exports.SecurityClient = SecurityClient;

node_modules/@ionic/cli-utils/lib/session.d.ts

@@ -0,0 +1,18 @@
+import { ConfigFile, IClient, IConfig, IProject, ISession } from '../definitions';
+export declare class BaseSession {
+    protected config: IConfig<ConfigFile>;
+    protected project: IProject;
+    protected client: IClient;
+    constructor(config: IConfig<ConfigFile>, project: IProject, client: IClient);
+    isLoggedIn(): Promise<boolean>;
+    logout(): Promise<void>;
+    getUserToken(): Promise<string>;
+}
+export declare class CloudSession extends BaseSession implements ISession {
+    login(email: string, password: string): Promise<void>;
+    getAppUserToken(app_id?: string): Promise<string>;
+}
+export declare class ProSession extends BaseSession implements ISession {
+    login(email: string, password: string): Promise<void>;
+    getAppUserToken(app_id?: string): Promise<string>;
+}

node_modules/@ionic/cli-utils/lib/session.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const guards_1 = require("../guards");
+const errors_1 = require("./errors");
+const http_1 = require("./http");
+class BaseSession {
+    constructor(config, project, client) {
+        this.config = config;
+        this.project = project;
+        this.client = client;
+    }
+    isLoggedIn() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const c = yield this.config.load();
+            return typeof c.tokens.user === 'string';
+        });
+    }
+    logout() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const c = yield this.config.load();
+            c.user = {};
+            c.tokens.appUser = {};
+            delete c.tokens.user;
+            c.git.setup = false;
+        });
+    }
+    getUserToken() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const c = yield this.config.load();
+            if (!c.tokens.user) {
+                throw new errors_1.FatalException(`Oops, sorry! You'll need to log in:\n\n    ${chalk.green('ionic login')}\n\n` +
+                    `You can create a new account by signing up:\n\n    ${chalk.green('ionic signup')}\n`);
+            }
+            return c.tokens.user;
+        });
+    }
+}
+exports.BaseSession = BaseSession;
+class CloudSession extends BaseSession {
+    login(email, password) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('POST', '/login')
+                .send({ email, password });
+            try {
+                const res = yield this.client.do(req);
+                if (!guards_1.isLegacyLoginResponse(res)) {
+                    throw http_1.createFatalAPIFormat(req, res);
+                }
+                const { token, user_id } = res.data;
+                const c = yield this.config.load();
+                if (c.user.id !== user_id) {
+                    yield this.logout();
+                }
+                c.user.id = user_id;
+                c.user.email = email;
+                c.tokens.user = token;
+            }
+            catch (e) {
+                if (guards_1.isSuperAgentError(e) && e.response.status === 401) {
+                    throw new errors_1.FatalException(chalk.red('Incorrect email or password'));
+                }
+                throw e;
+            }
+        });
+    }
+    getAppUserToken(app_id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!app_id) {
+                app_id = yield this.project.loadAppId();
+            }
+            const c = yield this.config.load();
+            if (!c.tokens.appUser[app_id]) {
+                const token = yield this.getUserToken();
+                const paginator = this.client.paginate(() => this.client.make('GET', '/auth/tokens').set('Authorization', `Bearer ${token}`).query({ 'page_size': 100, type: 'app-user' }), guards_1.isAuthTokensResponse);
+                for (let r of paginator) {
+                    const res = yield r;
+                    for (let token of res.data) {
+                        c.tokens.appUser[token.details.app_id] = token.token;
+                    }
+                }
+            }
+            // TODO: if this is a new app, an app-user token may not exist for the user
+            // TODO: if tokens are invalidated, what do (hint: app tokens)
+            if (!c.tokens.appUser[app_id]) {
+                throw new errors_1.FatalException(`A token does not exist for your account on app ${chalk.bold(app_id)}.`);
+            }
+            return c.tokens.appUser[app_id];
+        });
+    }
+}
+exports.CloudSession = CloudSession;
+class ProSession extends BaseSession {
+    login(email, password) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const req = this.client.make('POST', '/login')
+                .send({ email, password, source: 'cli' });
+            try {
+                const res = yield this.client.do(req);
+                if (!guards_1.isProLoginResponse(res)) {
+                    throw http_1.createFatalAPIFormat(req, res);
+                }
+                const { token, user } = res.data;
+                const c = yield this.config.load();
+                const user_id = String(user.id);
+                if (c.user.id !== user_id) {
+                    yield this.logout();
+                }
+                c.user.id = user_id;
+                c.user.email = email;
+                c.tokens.user = token;
+            }
+            catch (e) {
+                if (guards_1.isSuperAgentError(e) && e.response.status === 401) {
+                    throw new errors_1.FatalException(chalk.red('Incorrect email or password'));
+                }
+                throw e;
+            }
+        });
+    }
+    getAppUserToken(app_id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.getUserToken();
+        });
+    }
+}
+exports.ProSession = ProSession;

node_modules/@ionic/cli-utils/lib/shell.d.ts

@@ -0,0 +1,8 @@
+import { ILogger, IShell, IShellRunOptions, ITaskChain } from '../definitions';
+export declare const ERROR_SHELL_COMMAND_NOT_FOUND = "SHELL_COMMAND_NOT_FOUND";
+export declare class Shell implements IShell {
+    protected tasks: ITaskChain;
+    protected log: ILogger;
+    constructor(tasks: ITaskChain, log: ILogger);
+    run(command: string, args: string[], {showCommand, showError, fatalOnNotFound, fatalOnError, showExecution, truncateErrorOutput, ...crossSpawnOptions}: IShellRunOptions): Promise<string>;
+}

node_modules/@ionic/cli-utils/lib/shell.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const guards_1 = require("../guards");
+const errors_1 = require("./errors");
+const shell_1 = require("./utils/shell");
+exports.ERROR_SHELL_COMMAND_NOT_FOUND = 'SHELL_COMMAND_NOT_FOUND';
+class Shell {
+    constructor(tasks, log) {
+        this.tasks = tasks;
+        this.log = log;
+    }
+    run(command, args, _a) {
+        var { showCommand = true, showError = true, fatalOnNotFound = true, fatalOnError = true, showExecution, truncateErrorOutput } = _a, crossSpawnOptions = tslib_1.__rest(_a, ["showCommand", "showError", "fatalOnNotFound", "fatalOnError", "showExecution", "truncateErrorOutput"]);
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const fullCmd = command + ' ' + (args.length > 0 ? args.map(a => a.includes(' ') ? `"${a}"` : a).join(' ') : '');
+            const truncatedCmd = fullCmd.length > 80 ? fullCmd.substring(0, 80) + '...' : fullCmd;
+            const options = Object.assign({}, crossSpawnOptions);
+            if (showExecution) {
+                options.stdoutPipe = this.log.stream;
+                options.stderrPipe = this.log.stream;
+            }
+            if (showCommand) {
+                if (this.log.shouldLog('info')) {
+                    this.log.msg(`> ${chalk.green(fullCmd)}`);
+                }
+                if (!showExecution) {
+                    this.tasks.next('Running command');
+                }
+            }
+            try {
+                try {
+                    const out = yield shell_1.runcmd(command, args, options);
+                    if (showExecution) {
+                        this.log.nl();
+                    }
+                    if (showCommand && !showExecution) {
+                        this.tasks.end();
+                    }
+                    return out;
+                }
+                catch (e) {
+                    if (e.code === 'ENOENT') {
+                        if (fatalOnNotFound) {
+                            throw new errors_1.FatalException(`Command not found: ${chalk.green(command)}`, 127);
+                        }
+                        else {
+                            throw exports.ERROR_SHELL_COMMAND_NOT_FOUND;
+                        }
+                    }
+                    if (!guards_1.isExitCodeException(e)) {
+                        throw e;
+                    }
+                    let err = e.message || '';
+                    if (truncateErrorOutput && err.length > truncateErrorOutput) {
+                        err = `${chalk.bold('(truncated)')} ... ` + err.substring(err.length - truncateErrorOutput);
+                    }
+                    const helpLine = showExecution ? '.\n' : (err ? `:\n\n${err}` : ' with no output.\n');
+                    const publicErrorMsg = `An error occurred while running ${chalk.green(truncatedCmd)} (exit code ${e.exitCode})` + helpLine;
+                    const privateErrorMsg = `Subprocess (${chalk.green(command)}) encountered an error (exit code ${e.exitCode}).`;
+                    if (fatalOnError) {
+                        if (showError) {
+                            throw new errors_1.FatalException(publicErrorMsg, e.exitCode);
+                        }
+                        else {
+                            throw new errors_1.FatalException(privateErrorMsg, e.exitCode);
+                        }
+                    }
+                    else {
+                        if (showError) {
+                            this.log.error(publicErrorMsg);
+                        }
+                    }
+                    throw e;
+                }
+            }
+            catch (e) {
+                if (showCommand && !showExecution) {
+                    this.tasks.fail();
+                }
+                throw e;
+            }
+        });
+    }
+}
+exports.Shell = Shell;

node_modules/@ionic/cli-utils/lib/telemetry.d.ts

@@ -0,0 +1,21 @@
+import * as leekType from 'leek';
+import { ConfigFile, IClient, IConfig, IProject, ISession, ITelemetry, RootPlugin } from '../definitions';
+export declare class Telemetry implements ITelemetry {
+    client: IClient;
+    protected config: IConfig<ConfigFile>;
+    protected plugin: RootPlugin;
+    protected session: ISession;
+    protected project: IProject;
+    protected gaTracker: leekType;
+    constructor({config, client, session, plugin, project}: {
+        config: IConfig<ConfigFile>;
+        client: IClient;
+        session: ISession;
+        plugin: RootPlugin;
+        project: IProject;
+    });
+    protected setupGATracker(): Promise<void>;
+    resetToken(): Promise<void>;
+    sendCommand(command: string, args: string[]): Promise<void>;
+    sendError(error: any, type: string): Promise<void>;
+}

node_modules/@ionic/cli-utils/lib/telemetry.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const backends_1 = require("./backends");
+const modules_1 = require("./modules");
+const uuid_1 = require("./uuid");
+const GA_CODE = 'UA-44023830-30';
+class Telemetry {
+    constructor({ config, client, session, plugin, project }) {
+        this.config = config;
+        this.plugin = plugin;
+        this.client = client;
+        this.session = session;
+        this.project = project;
+    }
+    setupGATracker() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const Leek = modules_1.load('leek'); // TODO: typescript bug? can't await import
+            const config = yield this.config.load();
+            if (!config.tokens.telemetry) {
+                config.tokens.telemetry = uuid_1.generateUUID();
+            }
+            this.gaTracker = new Leek({
+                name: config.tokens.telemetry,
+                trackingCode: GA_CODE,
+                globalName: 'ionic',
+                version: this.plugin.version,
+                silent: config.telemetry !== true,
+            });
+        });
+    }
+    resetToken() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.config.load();
+            config.tokens.telemetry = uuid_1.generateUUID();
+        });
+    }
+    sendCommand(command, args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.gaTracker) {
+                yield this.setupGATracker();
+            }
+            const messageList = [];
+            const name = 'command execution';
+            const prettyArgs = args.map(a => a.includes(' ') ? `"${a}"` : a);
+            const message = messageList.concat([command], prettyArgs).join(' ');
+            yield Promise.all([
+                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield this.gaTracker.track({ name, message });
+                }))(),
+                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    const config = yield this.config.load();
+                    if (config.backend === backends_1.BACKEND_PRO) {
+                        let appId;
+                        if (this.project.directory) {
+                            const project = yield this.project.load();
+                            appId = project.app_id;
+                        }
+                        const now = new Date().toISOString();
+                        const isLoggedIn = yield this.session.isLoggedIn();
+                        let req = this.client.make('POST', '/events/metrics');
+                        if (isLoggedIn) {
+                            const token = yield this.session.getUserToken();
+                            req = req.set('Authorization', `Bearer ${token}`);
+                        }
+                        req = req.send({
+                            'metrics': [
+                                {
+                                    'name': 'cli_command_metrics',
+                                    'timestamp': now,
+                                    'session_id': config.tokens.telemetry,
+                                    'source': 'cli',
+                                    'value': {
+                                        'command': command,
+                                        'arguments': prettyArgs.join(' '),
+                                        'version': this.plugin.version,
+                                        'node_version': process.version,
+                                        'app_id': appId,
+                                    },
+                                },
+                            ],
+                            'sent_at': now,
+                        });
+                        try {
+                            yield this.client.do(req);
+                        }
+                        catch (e) {
+                            // TODO
+                        }
+                    }
+                }))(),
+            ]);
+        });
+    }
+    sendError(error, type) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.gaTracker.trackError({
+                description: error.message + ' ' + error.stack,
+                isFatal: true,
+            });
+        });
+    }
+}
+exports.Telemetry = Telemetry;

node_modules/@ionic/cli-utils/lib/utils/archive.d.ts

@@ -0,0 +1,2 @@
+import * as archiverType from 'archiver';
+export declare function createArchive(format: 'zip' | 'tar'): archiverType.Archiver;

node_modules/@ionic/cli-utils/lib/utils/archive.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+function createArchive(format) {
+    const archiver = modules_1.load('archiver');
+    return archiver(format);
+}
+exports.createArchive = createArchive;

node_modules/@ionic/cli-utils/lib/utils/array.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Recursively flatten an array.
+ */
+export declare function flattenArray(arr: any[]): any[];

node_modules/@ionic/cli-utils/lib/utils/array.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Recursively flatten an array.
+ */
+function flattenArray(arr) {
+    return arr.reduce(function (flat, toFlatten) {
+        return flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten);
+    }, []);
+}
+exports.flattenArray = flattenArray;

node_modules/@ionic/cli-utils/lib/utils/aws.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+export declare function s3SignedUpload(presignedPostParams: {
+    url: string;
+    fields: Object;
+}, zip: NodeJS.ReadableStream, {progress}: {
+    progress?: (loaded: number, total: number) => void;
+}): Promise<void>;

node_modules/@ionic/cli-utils/lib/utils/aws.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("../http");
+function s3SignedUpload(presignedPostParams, zip, { progress }) {
+    return new Promise((resolve, reject) => {
+        zip.on('error', (err) => {
+            reject(err);
+        });
+        let bufs = [];
+        zip.on('data', (buf) => {
+            bufs.push(buf);
+        });
+        zip.on('end', () => {
+            http_1.createRequest('post', presignedPostParams.url)
+                .buffer()
+                .field(presignedPostParams.fields)
+                .field('file', Buffer.concat(bufs))
+                .on('progress', (event) => {
+                if (progress) {
+                    progress(event.loaded, event.total);
+                }
+            })
+                .end((err, res) => {
+                if (err) {
+                    return reject(err);
+                }
+                if (res.status !== 204) {
+                    // TODO: log body for debug purposes?
+                    return reject(new Error(`Unexpected status code from AWS: ${res.status}`));
+                }
+                resolve();
+            });
+        });
+    });
+}
+exports.s3SignedUpload = s3SignedUpload;

node_modules/@ionic/cli-utils/lib/utils/environmentInfo.d.ts

@@ -0,0 +1 @@
+export declare function getCommandInfo(cmd: string, args?: string[]): Promise<string | undefined>;

node_modules/@ionic/cli-utils/lib/utils/environmentInfo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const shell_1 = require("./shell");
+function getCommandInfo(cmd, args = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const out = yield shell_1.runcmd(cmd, args);
+            return out.split('\n').join(' ');
+        }
+        catch (e) { }
+    });
+}
+exports.getCommandInfo = getCommandInfo;

node_modules/@ionic/cli-utils/lib/utils/format.d.ts

@@ -0,0 +1,17 @@
+export declare const ICON_ELLIPSIS: string;
+export declare const ICON_SUCCESS: string;
+export declare const ICON_FAILURE: string;
+export declare const SPINNER_FRAMES: string[];
+export declare const TTY_WIDTH: number;
+export declare function prettyPath(p: string): string;
+export declare function indent(n?: number): string;
+export declare function wordWrap(msg: string, {indentation, append}: {
+    indentation?: number;
+    append?: string;
+}): string;
+export declare function generateFillSpaceStringList(list: string[], optimalLength?: number, fillCharacter?: string): string[];
+export declare function columnar(rows: string[][], {hsep, vsep, columnHeaders}?: {
+    hsep?: string;
+    vsep?: string;
+    columnHeaders?: string[];
+}): string;

node_modules/@ionic/cli-utils/lib/utils/format.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = require("os");
+const path = require("path");
+const chalk = require("chalk");
+const stringWidth = require("string-width");
+const wrapAnsi = require("wrap-ansi");
+const modules_1 = require("../modules");
+const isWindows = process.platform === 'win32';
+exports.ICON_ELLIPSIS = isWindows ? '...' : '…';
+exports.ICON_SUCCESS = isWindows ? '√' : '✔';
+exports.ICON_FAILURE = isWindows ? '×' : '✖';
+exports.SPINNER_FRAMES = isWindows ?
+    ['-', '\\', '|', '/'] :
+    ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const MIN_TTY_WIDTH = 80;
+const MAX_TTY_WIDTH = 120;
+exports.TTY_WIDTH = process.stdout.columns ? Math.max(MIN_TTY_WIDTH, Math.min(process.stdout.columns, MAX_TTY_WIDTH)) : Infinity;
+function prettyPath(p) {
+    p = path.resolve(p);
+    const cwd = process.cwd();
+    const d = path.dirname(p);
+    const h = os.homedir();
+    const distanceFromCwd = Math.abs(d.split(path.sep).length - cwd.split(path.sep).length);
+    if (cwd === d) {
+        return '.' + path.sep + path.basename(p);
+    }
+    else if (d.startsWith(cwd)) {
+        return '.' + path.sep + p.substring(cwd.length + 1);
+    }
+    else if (distanceFromCwd <= 2) {
+        const rel = path.relative(cwd, p);
+        return rel ? rel : '.';
+    }
+    else if (p === h) {
+        return '~';
+    }
+    else if (p.indexOf(h) === 0) {
+        return '~' + path.sep + p.substring(h.length + 1);
+    }
+    return p;
+}
+exports.prettyPath = prettyPath;
+function indent(n = 4) {
+    return new Array(n).fill(' ').join('');
+}
+exports.indent = indent;
+function wordWrap(msg, { indentation = 0, append = '' }) {
+    return wrapAnsi(msg, exports.TTY_WIDTH - indentation - append.length).split('\n').join(`${append}\n${indent(indentation)}`);
+}
+exports.wordWrap = wordWrap;
+function generateFillSpaceStringList(list, optimalLength = 1, fillCharacter = ' ') {
+    const sliceAnsi = modules_1.load('slice-ansi');
+    const longestItem = Math.max(...list.map((item) => stringWidth(item)));
+    const fullLength = longestItem > optimalLength ? longestItem + 1 : optimalLength;
+    const fullLengthString = Array(fullLength).fill(fillCharacter).join('');
+    return list.map(item => sliceAnsi(fullLengthString, 0, fullLength - stringWidth(item)));
+}
+exports.generateFillSpaceStringList = generateFillSpaceStringList;
+function columnar(rows, { hsep = chalk.dim('-'), vsep = chalk.dim('|'), columnHeaders } = {}) {
+    const includeHeaders = columnHeaders ? true : false;
+    if (!rows[0]) {
+        return '';
+    }
+    const columnCount = columnHeaders ? columnHeaders.length : rows[0].length;
+    const columns = columnHeaders ?
+        columnHeaders.map(header => [chalk.bold(header)]) :
+        new Array(columnCount).fill([]).map(() => []);
+    for (let row of rows) {
+        for (let i in row) {
+            if (columns[i]) {
+                columns[i].push(row[i]);
+            }
+        }
+    }
+    const paddedColumns = columns.map((col, i) => {
+        if (i < columnCount - 1) {
+            const spaceCol = generateFillSpaceStringList(col);
+            return col.map((cell, i) => `${cell}${spaceCol[i]}${vsep} `);
+        }
+        else {
+            return col;
+        }
+    });
+    let longestRowLength = 0;
+    const singleColumn = paddedColumns.reduce((a, b) => {
+        return a.map((_, i) => {
+            const r = a[i] + b[i];
+            longestRowLength = Math.max(longestRowLength, stringWidth(r));
+            return r;
+        });
+    });
+    if (includeHeaders) {
+        singleColumn.splice(1, 0, hsep.repeat(longestRowLength));
+    }
+    return singleColumn.join('\n');
+}
+exports.columnar = columnar;

node_modules/@ionic/cli-utils/lib/utils/fs.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare const ERROR_FILE_NOT_FOUND = "FILE_NOT_FOUND";
+export declare const ERROR_FILE_INVALID_JSON = "FILE_INVALID_JSON";
+export declare const ERROR_OVERWRITE_DENIED = "OVERWRITE_DENIED";
+export interface FSReadFileOptions {
+    encoding: string;
+    flag?: string;
+}
+export interface FSWriteFileOptions {
+    encoding: string;
+    mode?: number;
+    flag?: string;
+}
+export declare const fsAccess: (arg1: string, arg2: number) => Promise<void>;
+export declare const fsMkdir: (arg1: string, arg2: number | undefined) => Promise<void>;
+export declare const fsOpen: (arg1: string, arg2: string) => Promise<number>;
+export declare const fsStat: (arg1: string) => Promise<fs.Stats>;
+export declare const fsUnlink: (arg1: string) => Promise<void>;
+export declare const fsReadFile: (arg1: string, arg2: FSReadFileOptions) => Promise<string>;
+export declare const fsWriteFile: (arg1: string, arg2: any, arg3: FSWriteFileOptions) => Promise<void>;
+export declare const fsReadDir: (arg1: string) => Promise<string[]>;
+export declare function readDir(filePath: string): Promise<string[]>;
+export declare function fsReadJsonFile(filePath: string, options?: FSReadFileOptions): Promise<{
+    [key: string]: any;
+}>;
+export declare function fsWriteJsonFile(filePath: string, json: {
+    [key: string]: any;
+}, options: FSWriteFileOptions): Promise<void>;
+export declare function fileToString(filepath: string): Promise<string>;
+export declare function fsMkdirp(p: string, mode?: number): Promise<void>;
+export declare function getFileChecksum(filePath: string): Promise<string>;
+export declare function writeStreamToFile(stream: NodeJS.ReadableStream, destination: string): Promise<any>;
+export declare function copyDirectory(source: string, destination: string): Promise<void>;
+export declare function copyFile(fileName: string, target: string, mode?: number): Promise<{}>;
+export declare function pathAccessible(filePath: string, mode: number): Promise<boolean>;
+export declare function pathExists(filePath: string): Promise<boolean>;
+/**
+ * Find the base directory based on the path given and a marker file to look for.
+ */
+export declare function findBaseDirectory(dir: string, file: string): Promise<string | undefined>;

node_modules/@ionic/cli-utils/lib/utils/fs.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = require("fs");
+const path = require("path");
+const promise_1 = require("./promise");
+exports.ERROR_FILE_NOT_FOUND = 'FILE_NOT_FOUND';
+exports.ERROR_FILE_INVALID_JSON = 'FILE_INVALID_JSON';
+exports.ERROR_OVERWRITE_DENIED = 'OVERWRITE_DENIED';
+exports.fsAccess = promise_1.promisify(fs.access);
+exports.fsMkdir = promise_1.promisify(fs.mkdir);
+exports.fsOpen = promise_1.promisify(fs.open);
+exports.fsStat = promise_1.promisify(fs.stat);
+exports.fsUnlink = promise_1.promisify(fs.unlink);
+exports.fsReadFile = promise_1.promisify(fs.readFile);
+exports.fsWriteFile = promise_1.promisify(fs.writeFile);
+exports.fsReadDir = promise_1.promisify(fs.readdir);
+function readDir(filePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield exports.fsReadDir(filePath);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return [];
+            }
+            throw e;
+        }
+    });
+}
+exports.readDir = readDir;
+function fsReadJsonFile(filePath, options = { encoding: 'utf8' }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const f = yield exports.fsReadFile(filePath, options);
+            return JSON.parse(f);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                throw exports.ERROR_FILE_NOT_FOUND;
+            }
+            else if (e instanceof SyntaxError) {
+                throw exports.ERROR_FILE_INVALID_JSON;
+            }
+            throw e;
+        }
+    });
+}
+exports.fsReadJsonFile = fsReadJsonFile;
+function fsWriteJsonFile(filePath, json, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return exports.fsWriteFile(filePath, JSON.stringify(json, null, 2) + '\n', options);
+    });
+}
+exports.fsWriteJsonFile = fsWriteJsonFile;
+function fileToString(filepath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield exports.fsReadFile(filepath, { encoding: 'utf8' });
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return '';
+            }
+            throw e;
+        }
+    });
+}
+exports.fileToString = fileToString;
+function fsMkdirp(p, mode) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const absPath = path.resolve(p);
+        const pathObj = path.parse(absPath);
+        const dirnames = absPath.split(path.sep).splice(1);
+        const dirs = dirnames.map((v, i) => path.resolve(pathObj.root, ...dirnames.slice(0, i), v));
+        for (let dir of dirs) {
+            try {
+                yield exports.fsMkdir(dir, mode);
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST') {
+                    throw e;
+                }
+            }
+        }
+    });
+}
+exports.fsMkdirp = fsMkdirp;
+function getFileChecksum(filePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const crypto = yield Promise.resolve().then(function () { return require('crypto'); });
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('md5');
+            const input = fs.createReadStream(filePath);
+            input.on('error', (err) => {
+                reject(err);
+            });
+            hash.once('readable', () => {
+                const fullChecksum = hash.read().toString('hex');
+                resolve(fullChecksum);
+            });
+            input.pipe(hash);
+        });
+    });
+}
+exports.getFileChecksum = getFileChecksum;
+function writeStreamToFile(stream, destination) {
+    return new Promise((resolve, reject) => {
+        const dest = fs.createWriteStream(destination);
+        stream.pipe(dest);
+        dest.on('error', reject);
+        dest.on('finish', resolve);
+    });
+}
+exports.writeStreamToFile = writeStreamToFile;
+function copyDirectory(source, destination) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const ncp = yield Promise.resolve().then(function () { return require('ncp'); });
+        return new Promise((resolve, reject) => {
+            ncp.ncp(source, destination, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                resolve();
+            });
+        });
+    });
+}
+exports.copyDirectory = copyDirectory;
+function copyFile(fileName, target, mode = 0o777) {
+    return new Promise((resolve, reject) => {
+        const rs = fs.createReadStream(fileName);
+        const ws = fs.createWriteStream(target, { mode: mode });
+        rs.on('error', reject);
+        ws.on('error', reject);
+        ws.on('open', function () {
+            rs.pipe(ws);
+        });
+        ws.once('finish', resolve);
+    });
+}
+exports.copyFile = copyFile;
+function pathAccessible(filePath, mode) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield exports.fsAccess(filePath, mode);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    });
+}
+exports.pathAccessible = pathAccessible;
+function pathExists(filePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return pathAccessible(filePath, fs.constants.F_OK);
+    });
+}
+exports.pathExists = pathExists;
+/**
+ * Find the base directory based on the path given and a marker file to look for.
+ */
+function findBaseDirectory(dir, file) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        dir = path.normalize(dir);
+        const dirInfo = path.parse(dir);
+        const directoriesToCheck = dirInfo.dir
+            .slice(dirInfo.root.length)
+            .split(path.sep)
+            .concat(dirInfo.base)
+            .map((segment, index, array) => {
+            let pathSegments = array.slice(0, (array.length - index));
+            return dirInfo.root + path.join(...pathSegments);
+        });
+        for (let i = 0; i < directoriesToCheck.length; i++) {
+            const results = yield exports.fsReadDir(directoriesToCheck[i]);
+            if (results.includes(file)) {
+                return directoriesToCheck[i];
+            }
+        }
+    });
+}
+exports.findBaseDirectory = findBaseDirectory;

node_modules/@ionic/cli-utils/lib/utils/logger.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import * as chalk from 'chalk';
+import { ILogger, LogLevel, LoggerOptions } from '../../definitions';
+export declare const LOGGER_STATUS_COLORS: Map<LogLevel, chalk.ChalkStyle>;
+export declare class Logger implements ILogger {
+    readonly level: LogLevel;
+    readonly prefix: string | (() => string);
+    stream: NodeJS.WritableStream;
+    constructor({level, prefix, stream}: LoggerOptions);
+    debug(msg: string | (() => string)): void;
+    info(msg: string | (() => string)): void;
+    ok(msg: string | (() => string)): void;
+    warn(msg: string | (() => string)): void;
+    error(msg: string | (() => string)): void;
+    msg(msg: string | (() => string)): void;
+    nl(num?: number): void;
+    shouldLog(level: LogLevel): boolean;
+    private enforceLF(str);
+    private getStatusColor(level);
+    private log(level, msg);
+}

node_modules/@ionic/cli-utils/lib/utils/logger.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const chalk = require("chalk");
+const guards_1 = require("../../guards");
+const format_1 = require("./format");
+exports.LOGGER_STATUS_COLORS = new Map([
+    ['debug', chalk.magenta.dim],
+    ['info', chalk.gray],
+    ['ok', chalk.green],
+    ['warn', chalk.yellow],
+    ['error', chalk.red],
+]);
+class Logger {
+    constructor({ level = 'info', prefix = '', stream = process.stdout }) {
+        this.level = level;
+        this.prefix = prefix;
+        this.stream = stream;
+    }
+    debug(msg) {
+        this.log('debug', msg);
+    }
+    info(msg) {
+        this.log('info', msg);
+    }
+    ok(msg) {
+        this.log('ok', msg);
+    }
+    warn(msg) {
+        this.log('warn', msg);
+    }
+    error(msg) {
+        this.log('error', msg);
+    }
+    msg(msg) {
+        if (typeof msg === 'function') {
+            msg = msg();
+        }
+        this.stream.write(this.enforceLF(msg));
+    }
+    nl(num = 1) {
+        this.stream.write(this.enforceLF('\n'.repeat(num)));
+    }
+    shouldLog(level) {
+        return guards_1.LOG_LEVELS.indexOf(level) >= guards_1.LOG_LEVELS.indexOf(this.level);
+    }
+    enforceLF(str) {
+        return str.match(/[\r\n]$/) ? str : str + '\n';
+    }
+    getStatusColor(level) {
+        const color = exports.LOGGER_STATUS_COLORS.get(level);
+        if (!color) {
+            return chalk;
+        }
+        return color;
+    }
+    log(level, msg) {
+        if (this.shouldLog(level)) {
+            let prefix = this.prefix;
+            if (typeof msg === 'function') {
+                msg = msg();
+            }
+            if (prefix) {
+                if (typeof prefix === 'function') {
+                    prefix = prefix();
+                }
+                msg = util.format(prefix, msg);
+            }
+            msg = format_1.wordWrap(msg, { indentation: level.length + 3 }).split('\n').join('\n');
+            msg = this.enforceLF(msg);
+            const color = this.getStatusColor(level);
+            const status = color.bold.bgBlack;
+            const b = chalk.dim;
+            this.stream.write(util.format.apply(util, [b('[') + status(level.toUpperCase()) + b(']'), msg]));
+        }
+    }
+}
+exports.Logger = Logger;

node_modules/@ionic/cli-utils/lib/utils/network.d.ts

@@ -0,0 +1,4 @@
+export declare const ERROR_NETWORK_ADDRESS_NOT_AVAIL = "NETWORK_ADDRESS_NOT_AVAIL";
+export declare function getAvailableIPAddress(): any[];
+export declare function findClosestOpenPort(host: string, port: number): Promise<number>;
+export declare function isPortTaken(host: string, port: number): Promise<boolean>;

node_modules/@ionic/cli-utils/lib/utils/network.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const os = require("os");
+const array_1 = require("./array");
+exports.ERROR_NETWORK_ADDRESS_NOT_AVAIL = 'NETWORK_ADDRESS_NOT_AVAIL';
+function getAvailableIPAddress() {
+    let interfaces = os.networkInterfaces();
+    return array_1.flattenArray(Object.keys(interfaces).map(deviceName => (interfaces[deviceName].map(item => ({
+        address: item.address,
+        deviceName,
+        family: item.family,
+        internal: item.internal
+    })))))
+        .filter(item => !item.internal && item.family === 'IPv4');
+}
+exports.getAvailableIPAddress = getAvailableIPAddress;
+function findClosestOpenPort(host, port) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        function t(portToCheck) {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const isTaken = yield isPortTaken(host, portToCheck);
+                if (!isTaken) {
+                    return portToCheck;
+                }
+                return t(portToCheck + 1);
+            });
+        }
+        return t(port);
+    });
+}
+exports.findClosestOpenPort = findClosestOpenPort;
+function isPortTaken(host, port) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const net = yield Promise.resolve().then(function () { return require('net'); });
+        return new Promise((resolve, reject) => {
+            const tester = net.createServer()
+                .once('error', (err) => {
+                if (err.code === 'EADDRNOTAVAIL') {
+                    reject(exports.ERROR_NETWORK_ADDRESS_NOT_AVAIL);
+                }
+                if (err.code !== 'EADDRINUSE') {
+                    return resolve(true);
+                }
+                resolve(true);
+            })
+                .once('listening', () => {
+                tester.once('close', () => {
+                    resolve(false);
+                })
+                    .close();
+            })
+                .on('error', (err) => {
+                reject(err);
+            })
+                .listen(port, host);
+        });
+    });
+}
+exports.isPortTaken = isPortTaken;

node_modules/@ionic/cli-utils/lib/utils/npm.d.ts

@@ -0,0 +1,25 @@
+import { BowerJson, DistTag, IShellRunOptions, IonicEnvironment, PackageJson } from '../../definitions';
+export declare const ERROR_INVALID_PACKAGE_JSON = "INVALID_PACKAGE_JSON";
+export declare const ERROR_INVALID_BOWER_JSON = "INVALID_BOWER_JSON";
+/**
+ * Lightweight version of https://github.com/npm/validate-npm-package-name
+ */
+export declare function isValidPackageName(name: string): boolean;
+export declare function readPackageJsonFile(path: string): Promise<PackageJson>;
+export declare function readBowerJsonFile(path: string): Promise<BowerJson>;
+export interface PkgManagerOptions extends IShellRunOptions {
+    command?: 'dedupe' | 'install' | 'uninstall';
+    pkg?: string;
+    global?: boolean;
+    link?: boolean;
+    save?: boolean;
+    saveDev?: boolean;
+    saveExact?: boolean;
+}
+/**
+ * Resolves pkg manager intent with command args.
+ *
+ * @return Promise<args> If the args is an empty array, it means the pkg manager doesn't have that command.
+ */
+export declare function pkgManagerArgs(env: IonicEnvironment, options?: PkgManagerOptions): Promise<string[]>;
+export declare function pkgLatestVersion(env: IonicEnvironment, pkg: string, distTag?: DistTag): Promise<string | undefined>;

node_modules/@ionic/cli-utils/lib/utils/npm.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const guards_1 = require("../../guards");
+const shell_1 = require("../shell");
+const fs_1 = require("./fs");
+exports.ERROR_INVALID_PACKAGE_JSON = 'INVALID_PACKAGE_JSON';
+exports.ERROR_INVALID_BOWER_JSON = 'INVALID_BOWER_JSON';
+let installer;
+/**
+ * Lightweight version of https://github.com/npm/validate-npm-package-name
+ */
+function isValidPackageName(name) {
+    return encodeURIComponent(name) === name;
+}
+exports.isValidPackageName = isValidPackageName;
+function readPackageJsonFile(path) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const packageJson = yield fs_1.fsReadJsonFile(path);
+        if (!guards_1.isPackageJson(packageJson)) {
+            throw exports.ERROR_INVALID_PACKAGE_JSON;
+        }
+        return packageJson;
+    });
+}
+exports.readPackageJsonFile = readPackageJsonFile;
+function readBowerJsonFile(path) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const bowerJson = yield fs_1.fsReadJsonFile(path);
+        if (!guards_1.isBowerJson(bowerJson)) {
+            throw exports.ERROR_INVALID_BOWER_JSON;
+        }
+        return bowerJson;
+    });
+}
+exports.readBowerJsonFile = readBowerJsonFile;
+/**
+ * Resolves pkg manager intent with command args.
+ *
+ * @return Promise<args> If the args is an empty array, it means the pkg manager doesn't have that command.
+ */
+function pkgManagerArgs(env, options = {}) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let vocab;
+        const config = yield env.config.load();
+        if (!options.command) {
+            options.command = 'install';
+        }
+        let command = options.command;
+        if (command === 'dedupe') {
+            delete options.pkg;
+            delete options.global;
+            delete options.link;
+            delete options.save;
+            delete options.saveDev;
+            delete options.saveExact;
+        }
+        else if (command === 'install' || command === 'uninstall') {
+            if (options.link) {
+                options.global = false;
+                if (command === 'install') {
+                    command = 'link';
+                }
+                else if (command === 'uninstall') {
+                    command = 'unlink';
+                }
+            }
+            if (options.global || options.link) {
+                options.save = false;
+                options.saveDev = false;
+                options.saveExact = false;
+            }
+            else if (options.pkg && typeof options.save === 'undefined' && typeof options.saveDev === 'undefined') {
+                options.save = true;
+            }
+            if (options.pkg && typeof options.saveExact === 'undefined') {
+                options.saveExact = true;
+            }
+        }
+        if (config.yarn) {
+            if (!installer) {
+                try {
+                    yield env.shell.run('yarn', ['--version'], { fatalOnNotFound: false, showCommand: false });
+                    installer = 'yarn';
+                }
+                catch (e) {
+                    if (e === shell_1.ERROR_SHELL_COMMAND_NOT_FOUND) {
+                        env.log.warn(`You have opted into yarn, but ${chalk.green('yarn')} was not found in PATH`);
+                    }
+                    else {
+                        env.log.debug(() => `Error running yarn: ${e}`);
+                    }
+                    installer = 'npm';
+                }
+            }
+        }
+        else {
+            installer = 'npm';
+        }
+        const installerArgs = [];
+        if (installer === 'npm') {
+            vocab = { install: 'install', bareInstall: 'install', uninstall: 'uninstall', dedupe: 'dedupe', global: '-g', save: '--save', saveDev: '--save-dev', saveExact: '--save-exact', nonInteractive: '' };
+        }
+        else if (installer === 'yarn') {
+            vocab = { install: 'add', bareInstall: 'install', uninstall: 'remove', dedupe: '', global: '', save: '', saveDev: '--dev', saveExact: '--exact', nonInteractive: '--non-interactive' };
+            if (options.global) {
+                installerArgs.push('global');
+            }
+        }
+        else {
+            throw new Error(`unknown installer: ${installer}`);
+        }
+        if (command === 'install') {
+            if (options.pkg) {
+                installerArgs.push(vocab.install);
+            }
+            else {
+                installerArgs.push(vocab.bareInstall);
+            }
+        }
+        else if (command === 'uninstall') {
+            installerArgs.push(vocab.uninstall);
+        }
+        else if (command === 'dedupe') {
+            if (vocab.dedupe) {
+                installerArgs.push(vocab.dedupe);
+            }
+            else {
+                return [];
+            }
+        }
+        else {
+            installerArgs.push(command);
+        }
+        if (options.global && vocab.global) {
+            installerArgs.push(vocab.global);
+        }
+        if (options.save && vocab.save) {
+            installerArgs.push(vocab.save);
+        }
+        if (options.saveDev && vocab.saveDev) {
+            installerArgs.push(vocab.saveDev);
+        }
+        if (options.saveExact && vocab.saveExact) {
+            installerArgs.push(vocab.saveExact);
+        }
+        if (vocab.nonInteractive) {
+            installerArgs.push(vocab.nonInteractive);
+        }
+        if (options.pkg) {
+            if (options.link) {
+                options.pkg = options.pkg.replace(/(.+)@.+/, '$1'); // Removes any dist tags in the pkg name, which link/unlink hate
+            }
+            installerArgs.push(options.pkg);
+        }
+        return [installer, ...installerArgs];
+    });
+}
+exports.pkgManagerArgs = pkgManagerArgs;
+function pkgLatestVersion(env, pkg, distTag = 'latest') {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const config = yield env.config.load();
+        const shellOptions = { fatalOnError: false, showCommand: false };
+        try {
+            if (config.yarn) {
+                const cmdResult = yield env.shell.run('yarn', ['info', pkg, `dist-tags.${distTag}`, '--json'], shellOptions);
+                return JSON.parse(cmdResult).data;
+            }
+            else {
+                const cmdResult = yield env.shell.run('npm', ['view', pkg, `dist-tags.${distTag}`, '--json'], shellOptions);
+                if (cmdResult) {
+                    return JSON.parse(cmdResult);
+                }
+            }
+        }
+        catch (e) {
+            if (e.fatal || !guards_1.isExitCodeException(e)) {
+                throw e;
+            }
+        }
+    });
+}
+exports.pkgLatestVersion = pkgLatestVersion;

node_modules/@ionic/cli-utils/lib/utils/promise.d.ts

@@ -0,0 +1,12 @@
+export interface Promisify {
+    <T>(func: (callback: (err: any, result?: T) => void) => void): () => Promise<T>;
+    <T, A1>(func: (arg1: A1, callback: (err: any, result?: T) => void) => void): (arg1: A1) => Promise<T>;
+    <T, A1, A2>(func: (arg1: A1, arg2: A2, callback: (err: any, result?: T) => void) => void): (arg1: A1, arg2: A2) => Promise<T>;
+    <T, A1, A2, A3>(func: (arg1: A1, arg2: A2, arg3: A3, callback: (err: any, result?: T) => void) => void): (arg1: A1, arg2: A2, arg3: A3) => Promise<T>;
+    <T, A1, A2, A3, A4>(func: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (err: any, result?: T) => void) => void): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Promise<T>;
+    <T, A1, A2, A3, A4, A5>(func: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (err: any, result?: T) => void) => void): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Promise<T>;
+}
+/**
+ * @example: const rReadFile = promisify<Buffer, string>(fs.readFile);
+ */
+export declare const promisify: Promisify;

node_modules/@ionic/cli-utils/lib/utils/promise.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @example: const rReadFile = promisify<Buffer, string>(fs.readFile);
+ */
+exports.promisify = function (func) {
+    return (...args) => {
+        return new Promise((resolve, reject) => {
+            func(...args, (err, response) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(response);
+            });
+        });
+    };
+};