forceios 9.2.0

package/README.md

@@ -0,0 +1,110 @@
+# Salesforce Mobile SDK for iOS Package
+
+The **forceios** npm package allows users to create iOS mobile applications to interface with the [Salesforce Platform](http://www.salesforce.com/platform/overview/), leveraging [Salesforce Mobile SDK for iOS](https://github.com/forcedotcom/SalesforceMobileSDK-iOS).
+
+## Getting Started
+
+If you're new to mobile development or the force.com platform, you may want to start at the [Mobile SDK landing page](http://wiki.developerforce.com/page/Mobile_SDK).  This page offers a variety of resources to help you determine the best technology path for creating your app, as well as many guides and blog posts detailing how to work with the Mobile SDK.
+
+But assuming you're all read up, here's how to get started with the **forceios** package to create the starting point for your mobile application.
+
+## Install the forceios Package
+
+Because forceios is a command-line utility, we recommend installing it globally, so that it's easily accessible on your path:
+
+        sudo npm install forceios -g
+
+You're of course welcome to install it locally as well:
+
+        npm install forceios
+
+In local installations, you can access the forceios app at `[Install Directory]/node_modules/.bin/forceios`.
+
+## Using forceios
+
+For the rest of this document, we'll assume that `forceios` is on your path.
+
+Typing `forceios` with no arguments gives you a breakdown of the usage:
+
+```
+-> forceios
+forceios: Tool for building an iOS native mobile application using Salesforce Mobile SDK
+
+Usage:
+
+# create an iOS native mobile application
+forceios create
+    [--apptype=application type (native_swift or native, leave empty for native_swift)]
+    --appname=application name
+    --packagename=app package identifier (e.g. com.mycompany.myapp)
+    --organization=organization name (your company's/organization's name)
+    [--outputdir=output directory (leave empty for current directory)]
+
+ OR 
+
+# create an iOS native mobile application from a template
+forceios createwithtemplate
+    --templaterepouri=template repo URI or Mobile SDK template name
+    --appname=application name
+    --packagename=app package identifier (e.g. com.mycompany.myapp)
+    --organization=organization name (your company's/organization's name)
+    [--outputdir=output directory (leave empty for current directory)]
+
+ OR 
+
+# list available Mobile SDK templates
+forceios listtemplates
+
+ OR 
+
+# validate store or syncs configuration
+forceios checkconfig
+    --configpath=path to store or syncs config to validate
+    --configtype=type of config to validate (store or syncs)
+
+ OR 
+
+# show version of Mobile SDK
+forceios version
+
+ OR 
+
+forceios
+```
+
+**Note:** You can specify any or all of the arguments as command line options as specified in the usage.  If you run `forceios create` with missing arguments, it prompts you for each missing option interactively.
+
+Once the creation script completes, you'll have a fully functioning basic application of the type you specified.  The new application has an Xcode workspace that you can peruse, run, and debug.
+
+### forceios create options
+
+**App Type:** \( *Optional* \) The type of application you wish to develop:
+
+- **native\_swift** (default) — A fully native iOS application written in Swift
+- **native** — A fully native iOS application written in Objective C
+
+**App Name:** The name of your application
+
+**App Package Identifier:** An identifier for your company, similar to a Java package (e.g. `com.acme.MobileApps`).  This concatenates with the app name to form the unique identifier for your app in the App Store.
+
+**Organization:** The name of your company or organization.  For example, `Acme Widgets, Inc.`
+
+**Output Directory:** \( *Optional* \) The folder where you want your app to be created.
+
+## More information
+
+- After your app has been created, you will see some on-screen instructions for next steps, such as building and running your app, importing the project into XCode, and changing the default Connected App (sample) configuration values to match your own Connected App.
+
+- You can find the `forcedroid` npm package [here](https://npmjs.org/package/forcedroid) to develop Mobile SDK apps for Android.
+
+- You can find the `forcehybrid` npm package [here](https://npmjs.org/package/forcehybrid) to develop Mobile SDK hybrid apps for iOS and Android.
+
+- You can find the `forcereact` npm package [here](https://npmjs.org/package/forcereact) to develop Mobile SDK react native apps for iOS and Android.
+
+- The Salesforce Mobile SDK for iOS source repository lives [here](https://github.com/forcedotcom/SalesforceMobileSDK-iOS).
+
+- The Salesforce Mobile SDK for Android source repository lives [here](https://github.com/forcedotcom/SalesforceMobileSDK-Android).
+
+- See [our developerforce site](http://wiki.developerforce.com/page/Mobile_SDK) for more information about how you can leverage Salesforce Mobile SDK with the force.com platform.
+
+- If you would like to make suggestions, have questions, or encounter any issues, we'd love to hear from you.  Post any feedback you have on [Salesforce StackExchange](https://salesforce.stackexchange.com/questions/tagged/mobilesdk).

package/forceios.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+/*
+ * Copyright (c) 2016-present, salesforce.com, inc.
+ * All rights reserved.
+ * Redistribution and use of this software in source and binary forms, with or
+ * without modification, are permitted provided that the following conditions
+ * are met:
+ * - Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of salesforce.com, inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission of salesforce.com, inc.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Dependencies
+var SDK = require('./shared/constants'),
+    createHelper = require('./shared/createHelper');
+
+
+// Do everything
+createHelper.createApp(SDK.forceclis.forceios);

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "forceios",
+	"version": "9.2.0",
+	"description": "Utilities for creating mobile apps based on the Salesforce Mobile SDK for iOS",
+	"keywords": [ "mobilesdk", "ios", "salesforce", "mobile", "sdk" ],
+	"homepage": "https://github.com/forcedotcom/SalesforceMobileSDK-iOS",
+	"bugs": "https://github.com/forcedotcom/SalesforceMobileSDK-iOS/issues",
+	"licenses" : [
+	    { "type": "Salesforce.com Mobile SDK License", "url": "https://github.com/forcedotcom/SalesforceMobileSDK-iOS/blob/master/LICENSE.md" }
+	],
+	"os" : [ "darwin" ],
+    "engines": {
+        "node": ">=7.0.0"
+    },
+	"bin" : { "forceios" : "forceios.js" },
+    "dependencies": {
+        "shelljs": "0.8.4",
+        "ajv": "^6.10.2",
+		"jsonlint": "^1.6.3"
+    },
+	"repository": {
+		"type" : "git",
+		"url" : "https://github.com/forcedotcom/SalesforceMobileSDK-Package.git"
+	},
+	"author": { "name": "Kevin Hawkins", "email": "khawkins@salesforce.com" },
+	"contributors": [
+        { "name": "Wolfgang Mathurin", "email": "wmathurin@salesforce.com" },
+        { "name": "Bharath Hariharan", "email": "bhariharan@salesforce.com" }
+    ]
+}

package/shared/commandLineUtils.js

@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2013-present, salesforce.com, inc.
+ * All rights reserved.
+ * Redistribution and use of this software in source and binary forms, with or
+ * without modification, are permitted provided that the following conditions
+ * are met:
+ * - Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of salesforce.com, inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission of salesforce.com, inc.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Helper module for parsing the command line arguments to our package front-end.
+
+var readline = require('readline');
+var outputColors = require('./outputColors');
+
+/**
+ * Parses an array of command line arguments, each of the form '--argName=argValue', or
+ * optionally, '--argName'. Treats '--argName=' as '--argName'.
+ *
+ * @param {Array} argsArray The array of String arguments of the specified format.
+ * @return A map in the form of { 'argName': 'argValue' [, ...] }
+ */ 
+var parseArgs = function(argsArray) {
+    var argMap = {};
+    for (var i = 0; i < argsArray.length; i++) {
+        var fullArg = argsArray[i];
+        var argSplitRegExp = /^--([^=]+)(=(.*))?$/;
+        if (!argSplitRegExp.test(fullArg)) {
+            throw new Error('Illegal argument: ' + fullArg);
+        }
+        var argName = fullArg.replace(argSplitRegExp, "$1");
+        argName = argName.toLocaleLowerCase();
+        var argVal = fullArg.replace(argSplitRegExp, "$3");
+        argMap[argName] = argVal;
+    }
+
+    return argMap;
+};
+
+/**
+ * A method to process command line arguments interactively.  Any arguments that were not specified
+ * on the command line will be prompted for on stdin, for the user to configure.
+ *
+ * @param {Array} argsArray The array of command line arguments (if any), of the form --argName=argValue, or --argName.
+ * @param {ArgProcessorList} argProcessorList A list of arguments and their various processing characteristics.
+ * @param {Function} callback The callback method to invoke once all arguments have been processed.
+ */
+var processArgsInteractive = function(argsArray, argProcessorList, callback) {
+    // Get any initial arguments from the command line.
+    var argsMap = parseArgs(argsArray);
+
+    processArgsInteractiveHelper(argsMap, argProcessorList, callback, 0);
+};
+
+/**
+ * (Recursive) helper function for processArgsInteractive.
+ * @param argsMap A map of arguments in the form of { 'argName': 'argValue' [, ...] }.
+ * @param {ArgProcessorList} argProcessorList A list of arguments and their various processing characteristics.
+ * @param {Function} callback The callback method to invoke once all arguments have been processed.
+ * @param {Number} currentIndex The index of the current argument being processed.
+ */
+var processArgsInteractiveHelper = function(argsMap, argProcessorList, callback, currentIndex) {
+    if (currentIndex === argProcessorList.processorList.length)
+        return callback(argsMap);
+
+    var argProcessor = argProcessorList.processorList[currentIndex];
+    var initialArgValue = argsMap[argProcessor.argName];
+
+    // Arg preprocessors determine whether an arg should even be presented as an option.
+    if (typeof argProcessor.preprocessorFunction === 'undefined') {
+        // By default, process each argument.
+        processArgument(initialArgValue, argsMap, argProcessor, function(resultArgValue) {
+            argsMap[argProcessor.argName] = resultArgValue;
+            processArgsInteractiveHelper(argsMap, argProcessorList, callback, currentIndex + 1);
+        });
+    } else {
+        var shouldProcessArgument = argProcessor.preprocessorFunction(argsMap);
+        if (shouldProcessArgument) {
+            processArgument(initialArgValue, argsMap, argProcessor, function(resultArgValue) {
+                argsMap[argProcessor.argName] = resultArgValue;
+                processArgsInteractiveHelper(argsMap, argProcessorList, callback, currentIndex + 1);
+            });
+        } else {
+            // If the user specified a value already, warn them that it won't be used.
+            if (typeof initialArgValue !== 'undefined') {
+                console.log(outputColors.yellow + 'WARNING: ' + outputColors.reset
+                    + '\'' + argProcessor.argName + '\' is not a valid argument in this scenario, and its value will be ignored.');
+                argsMap[argProcessor.argName] = undefined;
+            }
+            processArgsInteractiveHelper(argsMap, argProcessorList, callback, currentIndex + 1);
+        }
+    }
+};
+
+/**
+ * Evaluates an argument value against its argument processor
+ * @param {String} argValue The specified value of the argument.
+ * @param argsMap A map of arguments in the form of { 'argName': 'argValue' [, ...] }.
+ * @param {ArgProcessor} argProcessor The argument processor, used to evaluate the arg value.
+ * @param {Function} postProcessingCallback The callback to invoke once a valid arg value has been determined.
+ */
+var processArgument = function(argValue, argsMap, argProcessor, postProcessingCallback) {
+    // NB: If argValue is undefined (i.e. no initial command line input), even for optional arguments the user must
+    // be prompted at least once.
+    var processingResult = null;
+    if (typeof argValue !== 'undefined') {
+        processingResult = argProcessor.processorFunction(argValue, argsMap);
+        if (!(processingResult instanceof ArgProcessorOutput)) {
+            throw new Error ('Expecting processing result of type ArgProcessorOutput.  Got \'' + (typeof processingResult) + '\'.');
+        }
+        if (processingResult.isValid) {
+            if (typeof processingResult.replacementValue !== 'undefined') {
+                return postProcessingCallback(processingResult.replacementValue);
+            } else {
+                return postProcessingCallback(argValue);
+            }
+        }
+    }
+
+    // Otherwise, arg value was either not present, or not valid.  If the user actually entered an invalid value, show the error prompt.
+    if (processingResult && !processingResult.isValid) {
+        if (typeof processingResult.message !== 'undefined') {
+            console.log(outputColors.red + processingResult.message + outputColors.reset);
+        } else {
+            console.log(outputColors.red + 'Invalid value for \'' + argProcessor.argName + '\'.' + outputColors.reset);
+        }
+    }
+    // If we have an inputPrompt, prompt the user
+    if (argProcessor.inputPrompt) {
+        var rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(argProcessor.inputPrompt + ' ', function(answer) {
+            rl.close();
+            processArgument(answer, argsMap, argProcessor, postProcessingCallback);
+        });
+    }
+    else {
+        processArgument('', argsMap, argProcessor, postProcessingCallback);
+    }
+};
+
+/**
+ * Creates an instance of an ArgProcessorList.
+ *
+ * @constructor
+ */
+var ArgProcessorList = function() {
+    this.processorList = [];
+};
+
+/**
+ * Adds an ArgProcessor to the list of processors.
+ *
+ * @param {String} argName The name of the argument.
+ * @param {String} inputPrompt The prompt to show the user, when interactively configuring the arg value. If null, the user will not be prompted interactively.
+ * @param {Function} processorFunction The function used to validate the arg value.
+ * @param {Function} preprocessorFunction An optional function that can be used to determine whether the argument should be configured.
+ * @return {ArgProcessorList} The updated ArgProcessorList, for chaining calls.
+ */
+ArgProcessorList.prototype.addArgProcessor = function(argName, inputPrompt, processorFunction, preprocessorFunction) {
+    var argProcessor = new ArgProcessor(argName, inputPrompt, processorFunction, preprocessorFunction);
+    this.processorList.push(argProcessor);
+    return this;
+};
+
+/**
+ * Creates an instance of the ArgProcessor object.
+ *
+ * @constructor
+ * @param {String} argName The name of the argument.
+ * @param {String} inputPrompt The prompt to show the user, when interactively configuring the arg value. If null, the user will not be prompted interactively.
+ * @param {Function} processorFunction The function used to validate the arg value.
+ * @param {Function} preprocessorFunction An optional function that can be used to determine whether the argument should be configured.
+ */
+var ArgProcessor = function(argName, inputPrompt, processorFunction, preprocessorFunction) {
+    if ((typeof argName !== 'string') || argName.trim() === '') {
+        throw new Error('Invalid value for argName: \'' + argName + '\'.');
+    }
+    if (typeof processorFunction !== 'function') {
+        throw new Error('processorFunction should be a function.');
+    }
+    if ((typeof preprocessorFunction !== 'undefined') && (typeof preprocessorFunction !== 'function')) {
+        throw new Error('If defined, preprocessorFunction should be a function.');
+    }
+
+    this.argName = argName;
+    this.inputPrompt = inputPrompt;
+    this.processorFunction = processorFunction;
+    this.preprocessorFunction = preprocessorFunction;
+};
+
+/**
+ * Creates an instance of the ArgProcessorOutput object, used to return the result of processing an arg value.
+ *
+ * @constructor
+ * @param {Boolean} isValid Whether or not the arg value was a valid value.
+ * @param {String} messageOrReplacementValue Optional value. If arg is not valid, a message explaining the failure.  If valid, an optional replacment value for the argument.
+ */
+var ArgProcessorOutput = function(isValid, messageOrReplacementValue) {
+
+    // If an argument is valid (isValid == true), there won't need to be a message
+    // assocated with it.  And if it's not valid, you wouldn't provide a replacement
+    // value for it (at least in the workflow as defined—replacement values imply a
+    // "valid" alternative argument value).  Hence the single second argument serving
+    // two masters.  But we'll normalize the value for consumption.  NB: In either
+    // use case, this argument can be optional.
+
+    if (typeof isValid !== 'boolean') {
+        throw new Error('isValid should be a boolean value.');
+    }
+    this.isValid = isValid;
+
+    if (typeof messageOrReplacementValue !== 'undefined') {
+        if (this.isValid)
+            this.replacementValue = messageOrReplacementValue;
+        else
+            this.message = messageOrReplacementValue;
+    }
+};
+
+// Exports
+
+module.exports.parseArgs = parseArgs;
+module.exports.ArgProcessorList = ArgProcessorList;
+module.exports.processArgsInteractive = processArgsInteractive;
+module.exports.ArgProcessorOutput = ArgProcessorOutput;

package/shared/configHelper.js

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2016-present, salesforce.com, inc.
+ * All rights reserved.
+ * Redistribution and use of this software in source and binary forms, with or
+ * without modification, are permitted provided that the following conditions
+ * are met:
+ * - Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of salesforce.com, inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission of salesforce.com, inc.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Dependencies
+var path = require('path'),
+    shelljs = require('shelljs'),
+    SDK = require('./constants'),
+    COLOR = require('./outputColors'),
+    commandLineUtils = require('./commandLineUtils'),
+    logInfo = require('./utils').logInfo,
+    getTemplates = require('./templateHelper').getTemplates,
+    validateJson = require('./jsonChecker').validateJson;
+
+function applyCli(f, cli) {
+    return typeof f === 'function' ? f(cli): f;
+}
+
+function getArgsExpanded(cli, commandName) {
+    var argNames = applyCli(SDK.commands[commandName].args, cli);
+    return argNames
+        .map(argName => SDK.args[argName])
+        .map(arg =>
+             ({
+                 name: arg.name,
+                 'char': arg.char,
+                 description: applyCli(arg.description, cli),
+                 longDescription: applyCli(arg.longDescription, cli),
+                 prompt: applyCli(arg.prompt, cli),
+                 error: applyCli(arg.error, cli),
+                 validate: applyCli(arg.validate, cli),
+                 promptIf: arg.promptIf,
+                 required: arg.required === undefined ? true : arg.required,
+                 hasValue: arg.hasValue === undefined ? true : arg.hasValue,
+                 hidden: applyCli(arg.hidden, cli),
+                 type: arg.type
+             })
+            );
+
+}
+
+function getCommandExpanded(cli, commandName) {
+    var command = SDK.commands[commandName];
+    return {
+        name: command.name,
+        args: getArgsExpanded(cli, commandName),
+        description: applyCli(command.description, cli),
+        longDescription: applyCli(command.longDescription, cli),
+        help: applyCli(command.help, cli)
+    };
+}
+
+function readConfig(args, cli, handler) {
+    var commandLineArgs = args.slice(2, args.length);
+    var commandName = commandLineArgs.shift();
+    commandName = commandName ? commandName.toLowerCase() : commandName;
+
+    var processorList = null;
+
+    switch (commandName || '') {
+    case SDK.commands.version.name:
+        printVersion(cli);
+        process.exit(0);
+        break;
+    case SDK.commands.create.name:
+    case SDK.commands.createwithtemplate.name:
+        processorList = buildArgsProcessorList(cli, commandName);
+        commandLineUtils.processArgsInteractive(commandLineArgs, processorList, handler);
+        break;
+    case SDK.commands.checkconfig.name:
+        processorList = buildArgsProcessorList(cli, commandName);
+        commandLineUtils.processArgsInteractive(commandLineArgs, processorList, function (config) {
+            validateJson(config.configpath, config.configtype);
+        });
+        break;
+    case SDK.commands.listtemplates.name:
+        listTemplates(cli);
+        process.exit(0);
+        break;
+    default:
+        usage(cli);
+        process.exit(1);
+    };
+
+
+}
+
+function printVersion(cli) {
+    logInfo(cli.name + ' version ' + SDK.version);
+}
+
+function printArgs(cli, commandName) {
+    getArgsExpanded(cli, commandName)
+        .filter(arg => !arg.hidden)
+        .forEach(arg => logInfo('    ' + (!arg.required  ? '[' : '') + '--' + arg.name + '=' + arg.description + (!arg.required ? ']' : ''), COLOR.magenta));
+}
+
+function listTemplates(cli) {
+    var cliName = cli.name;
+    var applicableTemplates = getTemplates(cli);
+
+    logInfo('\nAvailable templates:\n', COLOR.cyan);
+    for (var i=0; i<applicableTemplates.length; i++) {
+        var template = applicableTemplates[i];
+        logInfo((i+1) + ') ' + template.description, COLOR.cyan);
+        logInfo(cliName + ' ' + SDK.commands.createwithtemplate.name + ' --' + SDK.args.templateRepoUri.name + '=' + template.path, COLOR.magenta);
+    }
+    logInfo('');
+}
+
+function usage(cli) {
+    var cliName = cli.name;
+    var cliVersion = SDK.version;
+    var appTypes = cli.appTypes;
+    var platforms = cli.platforms;
+
+    logInfo('\n' + cliName + ': Tool for building ' + cli.purpose + ' using Salesforce Mobile SDK', COLOR.cyan);
+    logInfo('\nUsage:\n', COLOR.cyan);
+    for (var i=0; i<cli.commands.length; i++) {
+        if (i>0) {
+            logInfo('\n OR \n', COLOR.cyan);
+        }
+        var commandName = cli.commands[i];
+        var command = getCommandExpanded(cli, commandName);
+        logInfo('# ' + command.description, COLOR.magenta);
+        logInfo(cliName + ' ' + commandName, COLOR.magenta);
+        printArgs(cli, commandName);
+    }
+    logInfo('\n OR \n', COLOR.cyan);
+    logInfo(cliName, COLOR.magenta);
+    logInfo('\nWe also offer:', COLOR.cyan);
+    for (var otherCliName in SDK.forceclis) {
+        var otherCli = SDK.forceclis[otherCliName];
+        if (otherCli.name != cli.name) {
+            logInfo('- ' + otherCli.name + ': Tool for building ' + otherCli.purpose + ' using Salesforce Mobile SDK', COLOR.cyan);
+        }
+    }
+    logInfo('\n');
+}
+
+//
+// Processor list
+//
+function buildArgsProcessorList(cli, commandName) {
+    var argProcessorList = new commandLineUtils.ArgProcessorList();
+
+    for (var arg of getArgsExpanded(cli, commandName)) {
+        addProcessorFor(argProcessorList, arg.name, arg.prompt, arg.error, arg.validate, arg.promptIf);
+    }
+
+    return argProcessorList;
+}
+
+//
+// Helper function to add arg processor
+// * argProcessorList: ArgProcessorList
+// * argName: string, name of argument
+// * prompt: string for prompt
+// * error: function
+// * validation: function or null (no validation)
+// * preprocessor: function or null
+//
+function addProcessorFor(argProcessorList, argName, prompt, error, validation, preprocessor) {
+    argProcessorList.addArgProcessor(argName, prompt, function(val) {
+        val = val.trim();
+
+        // validation is either a function or null
+        if (validation == null || validation(val)) {
+            return new commandLineUtils.ArgProcessorOutput(true, val);
+        }
+        else {
+            return new commandLineUtils.ArgProcessorOutput(false, error(val));
+        }
+
+    }, preprocessor);
+}
+
+module.exports = {
+    readConfig: readConfig,
+    printVersion: printVersion,
+    getArgsExpanded: getArgsExpanded,
+    getCommandExpanded: getCommandExpanded
+};