defang 0.5.28 → 0.5.36

package/README.md

@@ -0,0 +1,37 @@
+# Defang
+
+Defang is a radically simpler way for developers to develop, deploy, and debug cloud applications.
+
+- Public releases of the Defang CLI; [click here](https://github.com/DefangLabs/defang/releases/latest/) for the latest version
+- Sample projects in Golang, Python, Node.js, and many more languages and frameworks, that show you how to accomplish various tasks and deploy them to the DOP using a Docker Compose file and the Defang CLI.
+- Samples that show how to deploy an app using the [Defang Pulumi Provider](https://github.com/DefangLabs/pulumi-defang).
+
+## Getting started
+
+- Read our [Getting Started](https://docs.defang.io/docs/getting-started) page
+- Follow the installation instructions from the [Installing](https://docs.defang.io/docs/getting-started/installing) page
+- Take a look at our [Samples folder](https://github.com/DefangLabs/defang/tree/main/samples) for example projects in various programming languages.
+- Try the AI integration by running `defang generate`
+- Start your new service with `defang compose up`
+
+## Support
+
+- File any issues [right here on GitHub](https://github.com/DefangLabs/defang/issues)
+
+## Environment Variables
+
+The Defang CLI recognizes the following environment variables:
+
+- `COMPOSE_PROJECT_NAME` - The name of the project to use; overrides the name in the `compose.yaml` file
+- `DEFANG_ACCESS_TOKEN` - The access token to use for authentication; if not specified, uses token from `defang login`
+- `DEFANG_CD_BUCKET` - The S3 bucket to use for the BYOC CD pipeline; defaults to `defang-cd-bucket-…`
+- `DEFANG_CD_IMAGE` - The image to use for the Continuous Deployment (CD) pipeline; defaults to `public.ecr.aws/defang-io/cd:public-beta`
+- `DEFANG_DEBUG` - set this to `1` or `true` to enable debug logging
+- `DEFANG_DISABLE_ANALYTICS` - If set to `true`, disables sending analytics to Defang; defaults to `false`
+- `DEFANG_FABRIC` - The address of the Defang Fabric to use; defaults to `fabric-prod1.defang.dev`
+- `DEFANG_HIDE_HINTS` - If set to `true`, hides hints in the CLI output; defaults to `false`
+- `DEFANG_HIDE_UPDATE` - If set to `true`, hides the update notification; defaults to `false`
+- `DEFANG_PROVIDER` - The name of the cloud provider to use, `auto` (default), `aws`, or `defang`
+- `NO_COLOR` - If set to any value, disables color output; by default, color output is enabled depending on the terminal
+- `TZ` - The timezone to use for log timestamps: an IANA TZ name like `UTC` or `Europe/Amsterdam`; defaults to `Local`
+- `XDG_STATE_HOME` - The directory to use for storing state; defaults to `~/.local/state`

package/bin/cli.js

@@ -1,263 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const adm_zip_1 = __importDefault(require("adm-zip"));
-const axios_1 = __importDefault(require("axios"));
-const child_process = __importStar(require("child_process"));
-const fs_1 = require("fs");
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const tar = __importStar(require("tar"));
-const util_1 = require("util");
-const EXECUTABLE = "defang";
-const URL_LATEST_RELEASE = "https://api.github.com/repos/DefangLabs/defang/releases/latest";
-const HTTP_STATUS_OK = 200;
-const exec = (0, util_1.promisify)(child_process.exec);
-async function getLatestVersion() {
-    const response = await axios_1.default.get(URL_LATEST_RELEASE);
-    if (response.status !== HTTP_STATUS_OK) {
-        throw new Error(`Failed to get latest version from GitHub. Status code: ${response.status}`);
-    }
-    return response.data.tag_name.replace("v", "").trim();
-}
-async function downloadAppArchive(version, archiveFilename, outputPath) {
-    const repo = "DefangLabs/defang";
-    const downloadUrl = `https://github.com/${repo}/releases/download/v${version}/${archiveFilename}`;
-    const downloadTargetFile = path.join(outputPath, archiveFilename);
-    return await downloadFile(downloadUrl, downloadTargetFile);
-}
-async function downloadFile(downloadUrl, downloadTargetFile) {
-    try {
-        const response = await axios_1.default.get(downloadUrl, {
-            responseType: "arraybuffer",
-            headers: {
-                "Content-Type": "application/octet-stream",
-            },
-        });
-        if (response?.data === undefined) {
-            throw new Error(`Failed to download ${downloadUrl}. No data in response.`);
-        }
-        await fs_1.promises.writeFile(downloadTargetFile, response.data);
-        return downloadTargetFile;
-    }
-    catch (error) {
-        console.error(error);
-        await fs_1.promises.unlink(downloadTargetFile);
-        return null;
-    }
-}
-async function extractArchive(archiveFilePath, outputPath) {
-    let result = false;
-    const ext = path.extname(archiveFilePath).toLocaleLowerCase();
-    switch (ext) {
-        case ".zip":
-            result = await extractZip(archiveFilePath, outputPath);
-            break;
-        case ".gz":
-            result = extractTarGz(archiveFilePath, outputPath);
-            break;
-        default:
-            throw new Error(`Unsupported archive extension: ${ext}`);
-    }
-    return result;
-}
-async function extractZip(zipPath, outputPath) {
-    try {
-        const zip = new adm_zip_1.default(zipPath);
-        const result = zip.extractEntryTo(EXECUTABLE, outputPath, true, true);
-        await fs_1.promises.chmod(path.join(outputPath, EXECUTABLE), 755);
-        return result;
-    }
-    catch (error) {
-        console.error(`An error occurred during zip extraction: ${error}`);
-        return false;
-    }
-}
-function extractTarGz(tarGzFilePath, outputPath) {
-    try {
-        tar.extract({
-            cwd: outputPath,
-            file: tarGzFilePath,
-            sync: true,
-            strict: true,
-        }, [EXECUTABLE]);
-        return true;
-    }
-    catch (error) {
-        console.error(`An error occurred during tar.gz extraction: ${error}`);
-        return false;
-    }
-}
-async function deleteArchive(archiveFilePath) {
-    await fs_1.promises.unlink(archiveFilePath);
-}
-async function getVersion(filename) {
-    const data = await fs_1.promises.readFile(filename, "utf8");
-    const pkg = JSON.parse(data);
-    return pkg.version;
-}
-function getAppArchiveFilename(version, platform, arch) {
-    let compression = "zip";
-    switch (platform) {
-        case "windows":
-            platform = "windows";
-            break;
-        case "linux":
-            platform = "linux";
-            compression = "tar.gz";
-            break;
-        case "darwin":
-            platform = "macOS";
-            break;
-        default:
-            throw new Error(`Unsupported operating system: ${platform}`);
-    }
-    switch (arch) {
-        case "x64":
-            arch = "amd64";
-            break;
-        case "arm64":
-            arch = "arm64";
-            break;
-        default:
-            throw new Error(`Unsupported architecture: ${arch}`);
-    }
-    if (platform === "macOS") {
-        return `defang_${version}_${platform}.${compression}`;
-    }
-    return `defang_${version}_${platform}_${arch}.${compression}`;
-}
-async function install(version, saveDirectory) {
-    try {
-        console.log(`Getting latest defang cli`);
-        const filename = getAppArchiveFilename(version, os.platform(), os.arch());
-        const archiveFile = await downloadAppArchive(version, filename, saveDirectory);
-        if (archiveFile == null || archiveFile.length === 0) {
-            throw new Error(`Failed to download ${filename}`);
-        }
-        const result = await extractArchive(archiveFile, saveDirectory);
-        if (result === false) {
-            throw new Error(`Failed to install binaries!`);
-        }
-        await deleteArchive(archiveFile);
-    }
-    catch (error) {
-        console.error(error);
-    }
-}
-function getPathToExecutable() {
-    let extension = "";
-    if (["win32", "cygwin"].includes(process.platform)) {
-        extension = ".exe";
-    }
-    const executablePath = path.join(__dirname, `${EXECUTABLE}${extension}`);
-    try {
-        return require.resolve(executablePath);
-    }
-    catch (e) {
-        return null;
-    }
-}
-function extractCLIVersions(versionInfo) {
-    const versionRegex = /\d+\.\d+\.\d+/g;
-    const matches = versionInfo.match(versionRegex);
-    if (matches != null && matches.length >= 2) {
-        return {
-            defangCLI: matches[0],
-            latestCLI: matches[1],
-        };
-    }
-    else {
-        throw new Error("Could not extract CLI versions from the output.");
-    }
-}
-async function getVersionInfo() {
-    let result = { current: null, latest: null };
-    try {
-        const execPath = getPathToExecutable();
-        if (!execPath) {
-            const latestVersion = await getLatestVersion();
-            return { current: null, latest: latestVersion };
-        }
-        const versionInfo = await exec(execPath + " version");
-        const verInfo = extractCLIVersions(versionInfo.stdout);
-        result.current = verInfo.defangCLI;
-        result.latest = verInfo.latestCLI;
-    }
-    catch (error) {
-        console.error(error);
-    }
-    return result;
-}
-function extractCLIWrapperArgs(args) {
-    const cliParams = {
-        uselatest: true,
-    };
-    const outArgs = [];
-    for (const arg of args) {
-        const argLower = arg.toLowerCase().replaceAll(" ", "");
-        if (argLower.startsWith("--use-latest")) {
-            const startOfValue = argLower.indexOf("=");
-            if (startOfValue >= 0) {
-                if (argLower.slice(startOfValue + 1) == "false") {
-                    cliParams.uselatest = false;
-                }
-            }
-        }
-        else {
-            outArgs.push(arg);
-        }
-    }
-    return { cliParams, outArgs };
-}
-async function run() {
-    try {
-        const { cliParams, outArgs: args } = extractCLIWrapperArgs(process.argv.slice(2));
-        if (cliParams.uselatest) {
-            const { current, latest } = await getVersionInfo();
-            if (latest != null && (current == null || current != latest)) {
-                await install(latest, __dirname);
-            }
-        }
-        const pathToExec = getPathToExecutable();
-        if (!pathToExec) {
-            throw new Error("Could not find the defang executable.");
-        }
-        const processResult = child_process.spawnSync(pathToExec, args, {
-            stdio: "inherit",
-        });
-        processResult.error && console.error(processResult.error);
-        process.exitCode = processResult.status ?? 1;
-    }
-    catch (error) {
-        console.error(error);
-        process.exitCode = 2;
-    }
-}
-run();
+var clilib_1 = require("./clilib");
+(0, clilib_1.run)();

package/bin/clilib.js

@@ -0,0 +1,444 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+exports.run = run;
+var adm_zip_1 = __importDefault(require("adm-zip"));
+var axios_1 = __importDefault(require("axios"));
+var child_process = __importStar(require("child_process"));
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+var tar = __importStar(require("tar"));
+var util_1 = require("util");
+var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var EXECUTABLE = "defang";
+var URL_LATEST_RELEASE = "https://api.github.com/repos/DefangLabs/defang/releases/latest";
+var HTTP_STATUS_OK = 200;
+var exec = (0, util_1.promisify)(child_process.exec);
+function getLatestVersion() {
+    return __awaiter(this, void 0, void 0, function () {
+        var response;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4, axios_1.default.get(URL_LATEST_RELEASE)];
+                case 1:
+                    response = _c.sent();
+                    if ((response === null || response === void 0 ? void 0 : response.status) !== HTTP_STATUS_OK) {
+                        throw new Error("Failed to get latest version from GitHub. Status code: ".concat(response.status));
+                    }
+                    return [2, (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.tag_name) === null || _b === void 0 ? void 0 : _b.replace("v", "").trim()];
+            }
+        });
+    });
+}
+function downloadAppArchive(version, archiveFilename, outputPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var repo, downloadUrl, downloadTargetFile;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    repo = "DefangLabs/defang";
+                    downloadUrl = "https://github.com/".concat(repo, "/releases/download/v").concat(version, "/").concat(archiveFilename);
+                    downloadTargetFile = path.join(outputPath, archiveFilename);
+                    return [4, downloadFile(downloadUrl, downloadTargetFile)];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+}
+function downloadFile(downloadUrl, downloadTargetFile) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 5]);
+                    return [4, axios_1.default.get(downloadUrl, {
+                            responseType: "arraybuffer",
+                            headers: {
+                                "Content-Type": "application/octet-stream",
+                            },
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if ((response === null || response === void 0 ? void 0 : response.data) === undefined) {
+                        throw new Error("Failed to download ".concat(downloadUrl, ". No data in response."));
+                    }
+                    return [4, fs.promises.writeFile(downloadTargetFile, response.data)];
+                case 2:
+                    _a.sent();
+                    return [2, downloadTargetFile];
+                case 3:
+                    error_1 = _a.sent();
+                    console.error(error_1);
+                    return [4, fs.promises.unlink(downloadTargetFile)];
+                case 4:
+                    _a.sent();
+                    return [2, null];
+                case 5: return [2];
+            }
+        });
+    });
+}
+function extractArchive(archiveFilePath, outputPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, ext, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    result = false;
+                    ext = path.extname(archiveFilePath).toLocaleLowerCase();
+                    _a = ext;
+                    switch (_a) {
+                        case ".zip": return [3, 1];
+                        case ".gz": return [3, 3];
+                    }
+                    return [3, 4];
+                case 1: return [4, extractZip(archiveFilePath, outputPath)];
+                case 2:
+                    result = _b.sent();
+                    return [3, 5];
+                case 3:
+                    result = extractTarGz(archiveFilePath, outputPath);
+                    return [3, 5];
+                case 4: return [2, false];
+                case 5: return [2, result];
+            }
+        });
+    });
+}
+function extractZip(zipPath, outputPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var zip, result, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    zip = new adm_zip_1.default(zipPath);
+                    result = zip.extractEntryTo(EXECUTABLE, outputPath, true, true);
+                    return [4, fs.promises.chmod(path.join(outputPath, EXECUTABLE), 755)];
+                case 1:
+                    _a.sent();
+                    return [2, result];
+                case 2:
+                    error_2 = _a.sent();
+                    console.error("An error occurred during zip extraction: ".concat(error_2));
+                    return [2, false];
+                case 3: return [2];
+            }
+        });
+    });
+}
+function extractTarGz(tarGzFilePath, outputPath) {
+    try {
+        tar.extract({
+            cwd: outputPath,
+            file: tarGzFilePath,
+            sync: true,
+            strict: true,
+        }, [EXECUTABLE]);
+        return true;
+    }
+    catch (error) {
+        console.error("An error occurred during tar.gz extraction: ".concat(error));
+        return false;
+    }
+}
+function deleteArchive(archiveFilePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, fs.promises.unlink(archiveFilePath)];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    });
+}
+function getAppArchiveFilename(version, platform, arch) {
+    var compression = "zip";
+    if (!SEMVER_REGEX.test(version)) {
+        throw new Error("Unsupported version: ".concat(version));
+    }
+    switch (platform) {
+        case "win32":
+        case "windows":
+            platform = "windows";
+            break;
+        case "linux":
+            platform = "linux";
+            compression = "tar.gz";
+            break;
+        case "darwin":
+            platform = "macOS";
+            break;
+        default:
+            throw new Error("Unsupported operating system: ".concat(platform));
+    }
+    switch (arch) {
+        case "x64":
+            arch = "amd64";
+            break;
+        case "arm64":
+            arch = "arm64";
+            break;
+        default:
+            throw new Error("Unsupported architecture: ".concat(arch));
+    }
+    if (platform === "macOS") {
+        return "defang_".concat(version, "_").concat(platform, ".").concat(compression);
+    }
+    return "defang_".concat(version, "_").concat(platform, "_").concat(arch, ".").concat(compression);
+}
+function getPathToExecutable() {
+    var extension = "";
+    if (["win32", "cygwin"].includes(process.platform)) {
+        extension = ".exe";
+    }
+    var executablePath = path.join(__dirname, "".concat(EXECUTABLE).concat(extension));
+    try {
+        return require.resolve(executablePath);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function extractCLIVersions(versionInfo) {
+    var versionRegex = /\d+\.\d+\.\d+/g;
+    var matches = versionInfo.match(versionRegex);
+    if (matches != null && matches.length >= 2) {
+        return {
+            defangCLI: matches[0],
+            latestCLI: matches[1],
+        };
+    }
+    else {
+        throw new Error("Could not extract CLI versions from the output.");
+    }
+}
+function getVersionInfo() {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, execPath, latestVersion, versionInfo, verInfo, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { current: null, latest: null };
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 5, , 6]);
+                    execPath = getPathToExecutable();
+                    if (!!execPath) return [3, 3];
+                    return [4, getLatestVersion()];
+                case 2:
+                    latestVersion = _a.sent();
+                    return [2, { current: null, latest: latestVersion }];
+                case 3: return [4, exec(execPath + " version")];
+                case 4:
+                    versionInfo = _a.sent();
+                    verInfo = extractCLIVersions(versionInfo.stdout);
+                    result.current = verInfo.defangCLI;
+                    result.latest = verInfo.latestCLI;
+                    return [3, 6];
+                case 5:
+                    error_3 = _a.sent();
+                    console.error(error_3);
+                    return [3, 6];
+                case 6: return [2, result];
+            }
+        });
+    });
+}
+function extractCLIWrapperArgs(args) {
+    var cliParams = {
+        uselatest: true,
+    };
+    var outArgs = [];
+    for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+        var arg = args_1[_i];
+        var argLower = arg.toLowerCase().replaceAll(" ", "");
+        if (argLower.startsWith("--use-latest")) {
+            var startOfValue = argLower.indexOf("=");
+            if (startOfValue >= 0) {
+                if (argLower.slice(startOfValue + 1) == "false") {
+                    cliParams.uselatest = false;
+                }
+            }
+        }
+        else {
+            outArgs.push(arg);
+        }
+    }
+    return { cliParams: cliParams, outArgs: outArgs };
+}
+function getEndNameFromPath(pathLine) {
+    var executableName = path.basename(pathLine);
+    return executableName.split(".")[0];
+}
+function install(version, saveDirectory, os) {
+    return __awaiter(this, void 0, void 0, function () {
+        var filename, archiveFile, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 4, , 5]);
+                    console.log("Getting latest defang cli");
+                    filename = getAppArchiveFilename(version, os.platform, os.arch);
+                    return [4, downloadAppArchive(version, filename, saveDirectory)];
+                case 1:
+                    archiveFile = _a.sent();
+                    if (archiveFile == null || archiveFile.length === 0) {
+                        throw new Error("Failed to download ".concat(filename));
+                    }
+                    return [4, extractArchive(archiveFile, saveDirectory)];
+                case 2:
+                    result = _a.sent();
+                    if (result === false) {
+                        throw new Error("Failed to install binaries!");
+                    }
+                    return [4, deleteArchive(archiveFile)];
+                case 3:
+                    _a.sent();
+                    return [3, 5];
+                case 4:
+                    error_4 = _a.sent();
+                    console.error(error_4);
+                    throw error_4;
+                case 5: return [2];
+            }
+        });
+    });
+}
+function run() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, cliParams, args, _b, current, latest, pathToExec, commandline, processResult, error_5;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 4, , 5]);
+                    _a = extractCLIWrapperArgs(process.argv.slice(2)), cliParams = _a.cliParams, args = _a.outArgs;
+                    if (!cliParams.uselatest) return [3, 3];
+                    return [4, getVersionInfo()];
+                case 1:
+                    _b = _d.sent(), current = _b.current, latest = _b.latest;
+                    if (!(latest != null && (current == null || current != latest))) return [3, 3];
+                    return [4, install(latest, __dirname, {
+                            platform: process.platform,
+                            arch: process.arch,
+                        })];
+                case 2:
+                    _d.sent();
+                    _d.label = 3;
+                case 3:
+                    pathToExec = getPathToExecutable();
+                    if (!pathToExec) {
+                        throw new Error("Could not find the defang executable.");
+                    }
+                    commandline = ["npx", getEndNameFromPath(pathToExec)]
+                        .join(" ")
+                        .trim();
+                    processResult = child_process.spawnSync(pathToExec, args, {
+                        stdio: "inherit",
+                        env: __assign(__assign({}, process.env), { DEFANG_COMMAND_EXECUTOR: commandline }),
+                    });
+                    processResult.error && console.error(processResult.error);
+                    process.exitCode = (_c = processResult.status) !== null && _c !== void 0 ? _c : 1;
+                    return [3, 5];
+                case 4:
+                    error_5 = _d.sent();
+                    console.error(error_5);
+                    process.exitCode = 2;
+                    return [3, 5];
+                case 5: return [2];
+            }
+        });
+    });
+}
+var clilib = {
+    deleteArchive: deleteArchive,
+    downloadAppArchive: downloadAppArchive,
+    downloadFile: downloadFile,
+    extractArchive: extractArchive,
+    extractCLIVersions: extractCLIVersions,
+    extractCLIWrapperArgs: extractCLIWrapperArgs,
+    getAppArchiveFilename: getAppArchiveFilename,
+    getEndNameFromPath: getEndNameFromPath,
+    getLatestVersion: getLatestVersion,
+    getVersionInfo: getVersionInfo,
+    getPathToExecutable: getPathToExecutable,
+};
+exports.default = clilib;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "defang",
-  "version": "0.5.28",
+  "version": "0.5.36",
   "author": "Defang Software Labs Inc.",
   "description": "CLI for the Defang Opinionated Platform",
   "license": "MIT",
@@ -16,21 +16,53 @@
   "bugs": {
     "url": "https://github.com/DefangLabs/defang/issues"
   },
+  "mocha": {
+    "require": [
+      "ts-node/register"
+    ],
+    "extension": [
+      "ts",
+      "js"
+    ],
+    "spec": [
+      "test/**/*.spec.ts"
+    ],
+    "recursive": true
+  },
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "TS_NODE_PROJECT='./tsconfig-test.json' mocha -r ts-node/register --loader=ts-node/esm -trace-warnings --no-warnings=ExperimentalWarning test/*.spec.ts"
   },
   "dependencies": {
     "adm-zip": "^0.5.14",
-    "axios": "^1.6.8",
+    "axios": "^1.7.2",
+    "babel-register-esm": "^1.2.5",
     "https": "^1.0.0",
     "os": "^0.1.2",
     "tar": "^7.0.1"
   },
   "devDependencies": {
+    "@babel/core": "^7.24.7",
+    "@babel/preset-env": "^7.24.7",
+    "@babel/preset-typescript": "^7.24.7",
     "@types/adm-zip": "^0.5.5",
+    "@types/axios": "^0.14.0",
+    "@types/chai": "^4.3.16",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/mocha": "^10.0.7",
     "@types/node": "^20.12.7",
+    "@types/sinon": "^17.0.3",
+    "@types/source-map-support": "^0.5.10",
     "@types/tar": "^6.1.13",
-    "typescript": "^5.4.5"
+    "chai": "^5.1.1",
+    "chai-as-promised": "^8.0.0",
+    "cross-env": "^7.0.3",
+    "mocha": "^10.6.0",
+    "nyc": "^17.0.0",
+    "sinon": "^18.0.0",
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
   },
   "main": "./bin/cli.js"
 }

package/test/clilib.spec.ts

@@ -0,0 +1,214 @@
+//********************************
+// To run these tests do the following:
+//    1. In package.json set/add the field "type": "module"
+//    2. Run `npm test`
+//********************************
+import * as mocha from "mocha";
+import * as sinon from "sinon";
+import * as chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+
+import axios, { AxiosResponse } from "axios";
+import fs from "fs";
+import clilib from "../src/clilib.ts";
+
+chai.use(chaiAsPromised);
+const { assert, expect } = chai;
+
+var sandbox: sinon.SinonSandbox;
+
+describe("Testing getLatestVersion()", () => {
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it("sanity", async () => {
+    const mockResponse: AxiosResponse = {
+      status: 200,
+      data: {
+        tag_name: "v0.5.32",
+      },
+    } as AxiosResponse;
+    sandbox.stub(axios, "get").returns(Promise.resolve(mockResponse));
+
+    await expect(clilib.getLatestVersion()).to.eventually.equal("0.5.32");
+  });
+
+  it("bad HTTP Status", async () => {
+    const mockResponse: AxiosResponse = {
+      status: 500,
+    } as AxiosResponse;
+    sandbox.stub(axios, "get").returns(Promise.reject(mockResponse));
+
+    await expect(clilib.getLatestVersion()).to.be.rejected;
+  });
+
+  it("empty tag_name", async () => {
+    const mockResponse: AxiosResponse = {
+      status: 200,
+      data: {
+        tag_name: "",
+      },
+    } as AxiosResponse;
+    sandbox.stub(axios, "get").returns(Promise.resolve(mockResponse));
+
+    await expect(clilib.getLatestVersion()).to.eventually.equal("");
+  });
+
+  it("ill-formed tag_name", async () => {
+    const mockResponse: AxiosResponse = {
+      status: 200,
+      data: {},
+    } as AxiosResponse;
+    sandbox.stub(axios, "get").returns(Promise.resolve(mockResponse));
+
+    await expect(clilib.getLatestVersion()).to.eventually.be.undefined;
+  });
+});
+
+describe("Testing downloadFile()", () => {
+  let axiosGetStub: sinon.SinonStub;
+  let writeStub: sinon.SinonStub;
+  let unlinkStub: sinon.SinonStub;
+
+  let downloadFileName = "target";
+  const url = "url";
+  const header = {
+    responseType: "arraybuffer",
+    headers: {
+      "Content-Type": "application/octet-stream",
+    },
+  };
+  let mockResponse: AxiosResponse;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    downloadFileName = "target";
+    mockResponse = {
+      status: 200,
+      data: {},
+    } as AxiosResponse;
+
+    axiosGetStub = sandbox
+      .stub(axios, "get")
+      .returns(Promise.resolve(mockResponse));
+    writeStub = sandbox
+      .stub(fs.promises, "writeFile")
+      .callsFake(() => Promise.resolve());
+    unlinkStub = sandbox
+      .stub(fs.promises, "unlink")
+      .callsFake(() => Promise.resolve());
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it("sanity", async () => {
+    await expect(
+      clilib.downloadFile(url, downloadFileName)
+    ).to.eventually.equal(downloadFileName);
+
+    sinon.assert.calledWith(axiosGetStub, url, header);
+    sinon.assert.calledWith(writeStub, downloadFileName, mockResponse.data);
+    sinon.assert.notCalled(unlinkStub);
+  });
+
+  it("download fails path", async () => {
+    axiosGetStub.returns(Promise.reject("failed"));
+    const targetFile = await clilib.downloadFile(url, downloadFileName);
+    await expect(
+      clilib.downloadFile(url, downloadFileName)
+    ).to.eventually.equal(targetFile);
+
+    sinon.assert.calledWith(axiosGetStub, url, header);
+    sinon.assert.notCalled(writeStub);
+    sinon.assert.calledWith(unlinkStub, downloadFileName);
+  });
+
+  it("write failed", async () => {
+    writeStub.returns(Promise.reject("failed"));
+    await expect(clilib.downloadFile(url, downloadFileName)).to.eventually.null;
+    sinon.assert.calledWith(axiosGetStub, url, header);
+    sinon.assert.calledWith(unlinkStub, downloadFileName);
+  });
+});
+
+describe("Testing getAppArchiveFilename()", () => {
+  it("returns expected filename", () => {
+    const iterationData = [
+      ["0.0.0", "win32", "x64", "defang_0.0.0_windows_amd64.zip"],
+      ["0.1.0", "windows", "x64", "defang_0.1.0_windows_amd64.zip"],
+      ["0.2.9", "windows", "arm64", "defang_0.2.9_windows_arm64.zip"],
+      ["0.3.10", "linux", "x64", "defang_0.3.10_linux_amd64.tar.gz"],
+      ["0.4.21", "linux", "arm64", "defang_0.4.21_linux_arm64.tar.gz"],
+      ["0.5.45", "darwin", "arm64", "defang_0.5.45_macOS.zip"],
+      ["0.5.45", "darwin", "x64", "defang_0.5.45_macOS.zip"],
+    ] as const;
+    const testFunc = (
+      version: string,
+      platform: string,
+      arch: string,
+      expected: string
+    ) =>
+      expect(clilib.getAppArchiveFilename(version, platform, arch)).to.be.equal(
+        expected
+      );
+    iterationData.forEach((testData) => testFunc.call(null, ...testData));
+  });
+
+  it("check error cases", () => {
+    const iterationData = [
+      ["", "windows", "x64"],
+      ["0.2.9", "windows", "risc64"],
+      ["0.5.45", "darwin", "powerpc"],
+    ] as const;
+    const testFunc = (version: string, platform: string, arch: string) =>
+      expect(() =>
+        clilib.getAppArchiveFilename(version, platform, arch)
+      ).to.throw();
+    iterationData.forEach((testData) => testFunc.call(null, ...testData));
+  });
+});
+
+describe("Testing extractCLIVersions()", () => {
+  it("sanity", async () => {
+    const versionInfo =
+      "Defang CLI: v0.5.24\nLatest CLI: v0.5.32\nDefang Fabric: v0.5.0-643";
+    const expected = { defangCLI: "0.5.24", latestCLI: "0.5.32" };
+
+    expect(clilib.extractCLIVersions(versionInfo)).to.be.deep.equal(expected);
+  });
+
+  it("missing v in version text", async () => {
+    const versionInfo =
+      "Defang CLI: 0.5.24\nLatest CLI: 0.5.32\nDefang Fabric: v0.5.0-643";
+    const expected = { defangCLI: "0.5.24", latestCLI: "0.5.32" };
+
+    expect(clilib.extractCLIVersions(versionInfo)).to.be.deep.equal(expected);
+  });
+
+  it("missing Defang CLI", () => {
+    const versionInfo =
+      "Defang CLI: \nLatest CLI: v0.5.32\nDefang Fabric: v0.5.0-643";
+    assert.doesNotThrow(() => clilib.extractCLIVersions(versionInfo));
+  });
+
+  it("missing Latest CLI", () => {
+    const versionInfo =
+      "Defang CLI: v0.5.24\nLatest CLI: \nDefang Fabric: v0.5.0-643";
+    assert.doesNotThrow(() => clilib.extractCLIVersions(versionInfo));
+  });
+
+  it("no fabric version in input", async () => {
+    const versionInfo = "Defang CLI: v0.5.24\nLatest CLI: v0.5.32\n";
+    const expected = { defangCLI: "0.5.24", latestCLI: "0.5.32" };
+
+    expect(clilib.extractCLIVersions(versionInfo)).to.be.deep.equal(expected);
+  });
+});

package/tsconfig-test.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+      "baseUrl": "./",
+      "outDir": "bin",
+      "removeComments": true,
+      "target": "ES6",
+      "module": "ESNext",
+      "moduleResolution": "node",
+      "experimentalDecorators": true,
+      "strictPropertyInitialization": false,
+      "allowSyntheticDefaultImports":true,
+      "allowImportingTsExtensions": true,
+      "lib": ["es2021"],
+      "noEmit": true,
+      "isolatedModules": false,
+      "strict": false,
+      "noImplicitAny": false,
+      "typeRoots" : [
+        "../node_modules/@types"
+      ]
+    },
+    "include": ["src/**/*.ts", "test/cliexec.spec.ts"],
+    "exclude": ["node_modules", "**/*.spec.ts"]
+}