Changes needed to be able to install on osx

_build/app.js

@@ -0,0 +1,27 @@
+"use strict";
+var command = require("./lib/command");
+var common = require("./lib/common");
+var errHandler = require("./lib/errorhandler");
+var loader = require("./lib/loader");
+// Set app root
+common.APP_ROOT = __dirname;
+var Bootstrap;
+(function (Bootstrap) {
+    function begin() {
+        return command.getCommand().then(function (cmd) {
+            common.EXEC_PATH = cmd.execPath;
+            return loader.load(cmd.execPath, cmd.args).then(function (tfCommand) {
+                return tfCommand.showBanner().then(function () {
+                    return tfCommand.ensureInitialized().then(function (executor) {
+                        return executor(cmd);
+                    });
+                });
+            });
+        });
+    }
+    Bootstrap.begin = begin;
+})(Bootstrap || (Bootstrap = {}));
+Bootstrap.begin().then(function () {
+}).catch(function (reason) {
+    errHandler.errLog(reason);
+});

_build/exec/build/default.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var tfcommand_1 = require("../../lib/tfcommand");
+var args = require("../../lib/arguments");
+function getCommand(args) {
+    return new BuildBase(args);
+}
+exports.getCommand = getCommand;
+var BuildBase = (function (_super) {
+    __extends(BuildBase, _super);
+    function BuildBase() {
+        _super.apply(this, arguments);
+        this.description = "Commands for managing Builds.";
+    }
+    BuildBase.prototype.setCommandArgs = function () {
+        _super.prototype.setCommandArgs.call(this);
+        this.registerCommandArgument("definitionId", "Build Definition ID", "Identifies a build definition.", args.IntArgument, null);
+        this.registerCommandArgument("definitionName", "Build Definition Name", "Name of a Build Definition.", args.StringArgument, null);
+        this.registerCommandArgument("status", "Build Status", "Build status filter.", args.StringArgument, null);
+        this.registerCommandArgument("top", "Number of builds", "Maximum number of builds to return.", args.IntArgument, null);
+        this.registerCommandArgument("buildId", "Build ID", "Identifies a particular Build.", args.IntArgument);
+    };
+    BuildBase.prototype.exec = function (cmd) {
+        return this.getHelp(cmd);
+    };
+    return BuildBase;
+}(tfcommand_1.TfCommand));
+exports.BuildBase = BuildBase;

_build/exec/build/list.js

@@ -0,0 +1,77 @@
+"use strict";
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var buildBase = require("./default");
+var buildContracts = require("vso-node-api/interfaces/BuildInterfaces");
+var trace = require("../../lib/trace");
+function getCommand(args) {
+    return new BuildGetList(args);
+}
+exports.getCommand = getCommand;
+var BuildGetList = (function (_super) {
+    __extends(BuildGetList, _super);
+    function BuildGetList() {
+        _super.apply(this, arguments);
+        this.description = "Get a list of builds.";
+    }
+    BuildGetList.prototype.getHelpArgs = function () {
+        return ["definitionId", "definitionName", "status", "top", "project"];
+    };
+    BuildGetList.prototype.exec = function () {
+        var _this = this;
+        trace.debug("build-list.exec");
+        var buildapi = this.webApi.getBuildApi();
+        return Promise.all([
+            this.commandArgs.project.val(),
+            this.commandArgs.definitionId.val(),
+            this.commandArgs.definitionName.val(),
+            this.commandArgs.status.val(),
+            this.commandArgs.top.val()
+        ]).then(function (values) {
+            var project = values[0], definitionId = values[1], definitionName = values[2], status = values[3], top = values[4];
+            var definitions = null;
+            if (definitionId) {
+                definitions = [definitionId];
+            }
+            else if (definitionName) {
+                trace.debug("No definition Id provided, checking for definitions with name " + definitionName);
+                return buildapi.getDefinitions(project, definitionName).then(function (defs) {
+                    if (defs.length > 0) {
+                        definitions = [defs[0].id];
+                        return _this._getBuilds(buildapi, project, definitions, buildContracts.BuildStatus[status], top);
+                    }
+                    else {
+                        trace.debug("No definition found with name " + definitionName);
+                        throw new Error("No definition found with name " + definitionName);
+                    }
+                });
+            }
+            return _this._getBuilds(buildapi, project, definitions, buildContracts.BuildStatus[status], top);
+        });
+    };
+    BuildGetList.prototype.friendlyOutput = function (data) {
+        if (!data) {
+            throw new Error("no build supplied");
+        }
+        if (!(data instanceof Array)) {
+            throw new Error("expected an array of builds");
+        }
+        data.forEach(function (build) {
+            trace.println();
+            trace.info("id              : %s", build.id);
+            trace.info("definition name : %s", build.definition ? build.definition.name : "unknown");
+            trace.info("requested by    : %s", build.requestedBy ? build.requestedBy.displayName : "unknown");
+            trace.info("status          : %s", buildContracts.BuildStatus[build.status]);
+            trace.info("queue time      : %s", build.queueTime ? build.queueTime.toJSON() : "unknown");
+        });
+    };
+    BuildGetList.prototype._getBuilds = function (buildapi, project, definitions, status, top) {
+        // I promise that this was as painful to write as it is to read
+        return buildapi.getBuilds(project, definitions, null, null, null, null, null, null, buildContracts.BuildStatus[status], null, null, null, top, null, null, null, null, null, null, null, null);
+    };
+    return BuildGetList;
+}(buildBase.BuildBase));
+exports.BuildGetList = BuildGetList;

_build/exec/build/queue.js

@@ -0,0 +1,77 @@
+"use strict";
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var buildBase = require("./default");
+var buildContracts = require("vso-node-api/interfaces/BuildInterfaces");
+var trace = require("../../lib/trace");
+function describe() {
+    return "queue a build";
+}
+exports.describe = describe;
+function getCommand(args) {
+    return new BuildQueue(args);
+}
+exports.getCommand = getCommand;
+var BuildQueue = (function (_super) {
+    __extends(BuildQueue, _super);
+    function BuildQueue() {
+        _super.apply(this, arguments);
+        this.description = "Queue a build.";
+    }
+    BuildQueue.prototype.getHelpArgs = function () {
+        return ["project", "definitionId", "definitionName"];
+    };
+    BuildQueue.prototype.exec = function () {
+        var _this = this;
+        var buildapi = this.webApi.getBuildApi();
+        return this.commandArgs.project.val().then(function (project) {
+            return _this.commandArgs.definitionId.val(true).then(function (definitionId) {
+                var definitionPromise;
+                if (definitionId) {
+                    definitionPromise = buildapi.getDefinition(definitionId, project);
+                }
+                else {
+                    definitionPromise = _this.commandArgs.definitionName.val().then(function (definitionName) {
+                        trace.debug("No definition id provided, Searching for definitions with name: " + definitionName);
+                        return buildapi.getDefinitions(project, definitionName).then(function (definitions) {
+                            if (definitions.length > 0) {
+                                var definition = definitions[0];
+                                return definition;
+                            }
+                            else {
+                                trace.debug("No definition found with name " + definitionName);
+                                throw new Error("No definition found with name " + definitionName);
+                            }
+                        });
+                    });
+                }
+                return definitionPromise.then(function (definition) {
+                    return _this._queueBuild(buildapi, definition, project);
+                });
+            });
+        });
+    };
+    BuildQueue.prototype.friendlyOutput = function (build) {
+        if (!build) {
+            throw new Error("no build supplied");
+        }
+        trace.println();
+        trace.info("id              : %s", build.id);
+        trace.info("definition name : %s", build.definition ? build.definition.name : "unknown");
+        trace.info("requested by    : %s", build.requestedBy ? build.requestedBy.displayName : "unknown");
+        trace.info("status          : %s", buildContracts.BuildStatus[build.status]);
+        trace.info("queue time      : %s", build.queueTime ? build.queueTime.toJSON() : "unknown");
+    };
+    BuildQueue.prototype._queueBuild = function (buildapi, definition, project) {
+        trace.debug("Queueing build...");
+        var build = {
+            definition: definition
+        };
+        return buildapi.queueBuild(build, project);
+    };
+    return BuildQueue;
+}(buildBase.BuildBase));
+exports.BuildQueue = BuildQueue;

_build/exec/build/show.js

@@ -0,0 +1,46 @@
+"use strict";
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var buildBase = require("./default");
+var buildContracts = require("vso-node-api/interfaces/BuildInterfaces");
+var trace = require("../../lib/trace");
+function getCommand(args) {
+    return new BuildShow(args);
+}
+exports.getCommand = getCommand;
+var BuildShow = (function (_super) {
+    __extends(BuildShow, _super);
+    function BuildShow() {
+        _super.apply(this, arguments);
+        this.description = "Show build details.";
+    }
+    BuildShow.prototype.getHelpArgs = function () {
+        return ["project", "buildId"];
+    };
+    BuildShow.prototype.exec = function () {
+        var _this = this;
+        trace.debug("build-show.exec");
+        var buildapi = this.webApi.getBuildApi();
+        return this.commandArgs.project.val().then(function (project) {
+            return _this.commandArgs.buildId.val().then(function (buildId) {
+                return buildapi.getBuild(buildId, project);
+            });
+        });
+    };
+    BuildShow.prototype.friendlyOutput = function (build) {
+        if (!build) {
+            throw new Error("no build supplied");
+        }
+        trace.println();
+        trace.info("id              : %s", build.id);
+        trace.info("definition name : %s", build.definition ? build.definition.name : "unknown");
+        trace.info("requested by    : %s", build.requestedBy ? build.requestedBy.displayName : "unknown");
+        trace.info("status          : %s", buildContracts.BuildStatus[build.status]);
+        trace.info("queue time      : %s", build.queueTime ? build.queueTime.toJSON() : "unknown");
+    };
+    return BuildShow;
+}(buildBase.BuildBase));
+exports.BuildShow = BuildShow;