defang 1.1.16 → 1.1.18

package/bin/cli.js

@@ -1,5 +1,3 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var clilib_1 = require("./clilib");
-(0, clilib_1.run)();
+import { run } from "./clilib.js";
+run();

package/bin/clilib.js

@@ -1,215 +1,82 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["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 };
+import AdmZip from "adm-zip";
+import axios from "axios";
+import * as child_process from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as tar from "tar";
+import { promisify } from "util";
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const 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-]+)*))?$/;
+const EXECUTABLE = "defang";
+const URL_LATEST_RELEASE = "https://api.github.com/repos/DefangLabs/defang/releases/latest";
+const HTTP_STATUS_OK = 200;
+const exec = promisify(child_process.exec);
+async function getLatestVersion() {
+    const response = await axios.get(URL_LATEST_RELEASE);
+    if (response.status !== HTTP_STATUS_OK) {
+        throw new Error(`Failed to get latest version from GitHub. Status code: ${response.status}`);
     }
-};
-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.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()];
-            }
-        });
-    });
+    return response.data?.tag_name?.replace("v", "").trim();
 }
-function downloadAppArchive(archiveFilename, outputPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var downloadUrl, downloadTargetFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    downloadUrl = "https://s.defang.io/".concat(archiveFilename, "?x-defang-source=npm");
-                    downloadTargetFile = path.join(outputPath, archiveFilename);
-                    return [4, downloadFile(downloadUrl, downloadTargetFile)];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+async function downloadAppArchive(archiveFilename, outputPath) {
+    const downloadUrl = `https://s.defang.io/${archiveFilename}?x-defang-source=npm`;
+    const downloadTargetFile = path.join(outputPath, archiveFilename);
+    return await downloadFile(downloadUrl, downloadTargetFile);
 }
-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.data == null) {
-                        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];
-            }
+async function downloadFile(downloadUrl, downloadTargetFile) {
+    try {
+        const response = await axios.get(downloadUrl, {
+            responseType: "arraybuffer",
+            headers: {
+                "Content-Type": "application/octet-stream",
+            },
         });
-    });
+        if (response.data == null) {
+            throw new Error(`Failed to download ${downloadUrl}. No data in response.`);
+        }
+        await fs.promises.writeFile(downloadTargetFile, response.data);
+        return downloadTargetFile;
+    }
+    catch (error) {
+        console.error(error);
+        await fs.promises.unlink(downloadTargetFile);
+        return null;
+    }
 }
-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];
-            }
-        });
-    });
+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:
+            return false;
+    }
+    return 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];
-            }
-        });
-    });
+async function extractZip(zipPath, outputPath) {
+    try {
+        const zip = new AdmZip(zipPath);
+        let extension = "";
+        if (["win32", "cygwin"].includes(process.platform)) {
+            extension = ".exe";
+        }
+        const executableFullName = EXECUTABLE + extension;
+        const result = zip.extractEntryTo(executableFullName, outputPath, true, true);
+        await fs.promises.chmod(path.join(outputPath, executableFullName), 755);
+        return result;
+    }
+    catch (error) {
+        console.error(`An error occurred during zip extraction: ${error}`);
+        return false;
+    }
 }
 function extractTarGz(tarGzFilePath, outputPath) {
     try {
@@ -222,26 +89,17 @@ function extractTarGz(tarGzFilePath, outputPath) {
         return true;
     }
     catch (error) {
-        console.error("An error occurred during tar.gz extraction: ".concat(error));
+        console.error(`An error occurred during tar.gz extraction: ${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];
-            }
-        });
-    });
+async function deleteArchive(archiveFilePath) {
+    await fs.promises.unlink(archiveFilePath);
 }
 function getAppArchiveFilename(version, platform, arch) {
-    var compression = "zip";
+    let compression = "zip";
     if (!SEMVER_REGEX.test(version)) {
-        throw new Error("Unsupported version: ".concat(version));
+        throw new Error(`Unsupported version: ${version}`);
     }
     switch (platform) {
         case "win32":
@@ -256,7 +114,7 @@ function getAppArchiveFilename(version, platform, arch) {
             platform = "macOS";
             break;
         default:
-            throw new Error("Unsupported operating system: ".concat(platform));
+            throw new Error(`Unsupported operating system: ${platform}`);
     }
     switch (arch) {
         case "x64":
@@ -266,81 +124,70 @@ function getAppArchiveFilename(version, platform, arch) {
             arch = "arm64";
             break;
         default:
-            throw new Error("Unsupported architecture: ".concat(arch));
+            throw new Error(`Unsupported architecture: ${arch}`);
     }
     if (platform === "macOS") {
-        return "defang_".concat(version, "_").concat(platform, ".").concat(compression);
+        return `defang_${version}_${platform}.${compression}`;
     }
-    return "defang_".concat(version, "_").concat(platform, "_").concat(arch, ".").concat(compression);
+    return `defang_${version}_${platform}_${arch}.${compression}`;
 }
 function getPathToExecutable() {
-    var extension = "";
+    let extension = "";
     if (["win32", "cygwin"].includes(process.platform)) {
         extension = ".exe";
     }
-    var executablePath = path.join(__dirname, "".concat(EXECUTABLE).concat(extension));
+    const executablePath = path.join(__dirname, `${EXECUTABLE}${extension}`);
     try {
-        return require.resolve(executablePath);
+        return fs.existsSync(executablePath) ? executablePath : null;
     }
     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.");
+    const regex = /^([A-Za-z ]+):\s*v?(\d+\.\d+\.\d+(?:-[\w.-]+)?)$/gm;
+    const versions = {
+        defangCLI: null,
+        latestCLI: null,
+    };
+    for (const [, label, version] of versionInfo.matchAll(regex)) {
+        const key = label.trim().toLowerCase();
+        if (key === "defang cli")
+            versions.defangCLI = version;
+        else if (key === "latest cli")
+            versions.latestCLI = version;
     }
+    return versions;
 }
-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];
-            }
-        });
-    });
+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(quoteIfNeeded(execPath) + " version");
+        const verInfo = extractCLIVersions(versionInfo.stdout);
+        result.current = verInfo.defangCLI;
+        result.latest = verInfo.latestCLI;
+        verInfo.defangCLI ?? console.warn("Defang CLI version not found");
+        verInfo.latestCLI ?? console.warn("Latest CLI version not found");
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return result;
 }
 function extractCLIWrapperArgs(args) {
-    var cliParams = {
+    const 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(" ", "");
+    const outArgs = [];
+    for (const arg of args) {
+        const argLower = arg.toLowerCase().replaceAll(" ", "");
         if (argLower.startsWith("--use-latest")) {
-            var startOfValue = argLower.indexOf("=");
+            const startOfValue = argLower.indexOf("=");
             if (startOfValue >= 0) {
                 if (argLower.slice(startOfValue + 1) == "false") {
                     cliParams.uselatest = false;
@@ -351,103 +198,76 @@ function extractCLIWrapperArgs(args) {
             outArgs.push(arg);
         }
     }
-    return { cliParams: cliParams, outArgs: outArgs };
+    return { cliParams, outArgs };
 }
 function getEndNameFromPath(pathLine) {
-    var executableName = path.basename(pathLine);
+    const 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(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];
-            }
-        });
-    });
+export async function install(version, saveDirectory, os) {
+    try {
+        console.log(`Getting latest defang cli`);
+        const filename = getAppArchiveFilename(version, os.platform, os.arch);
+        const archiveFile = await downloadAppArchive(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);
+        throw error;
+    }
 }
-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];
+function quoteIfNeeded(p) {
+    return /\s/.test(p) ? `"${p}"` : p;
+}
+export 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, {
+                    platform: process.platform,
+                    arch: process.arch,
+                });
             }
+        }
+        const pathToExec = getPathToExecutable();
+        if (!pathToExec) {
+            throw new Error("Could not find the defang executable.");
+        }
+        const commandline = ["npx", quoteIfNeeded(getEndNameFromPath(pathToExec))]
+            .join(" ")
+            .trim();
+        const processResult = child_process.spawnSync(pathToExec, args, {
+            stdio: "inherit",
+            env: { ...process.env, DEFANG_COMMAND_EXECUTOR: commandline },
         });
-    });
+        processResult.error && console.error(processResult.error);
+        process.exitCode = processResult.status ?? 1;
+    }
+    catch (error) {
+        console.error(error);
+        process.exitCode = 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,
+const clilib = {
+    deleteArchive,
+    downloadAppArchive,
+    downloadFile,
+    extractArchive,
+    extractCLIVersions,
+    extractCLIWrapperArgs,
+    getAppArchiveFilename,
+    getEndNameFromPath,
+    getLatestVersion,
+    getVersionInfo,
+    getPathToExecutable,
 };
-exports.default = clilib;
+export default clilib;

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "defang",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "author": "Defang Software Labs Inc.",
   "description": "CLI to take your app from Docker Compose to a secure and scalable deployment on your favorite cloud in minutes",
   "license": "MIT",
+  "type": "module",
+  "ts-node": {
+    "esm": true
+  },
   "bin": {
     "defang": "bin/cli.js"
   },
@@ -30,9 +34,9 @@
     "recursive": true
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc -p tsconfig.json",
     "postbuild": "chmod +x bin/cli.js",
-    "test": "mocha -r ts-node/register -trace-warnings 'test/**/*.spec.ts'"
+    "test": "tsx --tsconfig tsconfig.test.json mocha.ts"
   },
   "dependencies": {
     "adm-zip": "^0.5.14",
@@ -43,19 +47,17 @@
     "@types/adm-zip": "^0.5.5",
     "@types/chai": "^5.1.1",
     "@types/chai-as-promised": "^8.0.0",
-    "@types/mocha": "^10.0.7",
+    "@types/mocha": "^10.0.10",
     "@types/node": "^20.12.7",
     "@types/sinon": "^17.0.3",
-    "@types/source-map-support": "^0.5.10",
     "@types/tar": "^6.1.13",
     "chai": "^5.1.1",
     "chai-as-promised": "^8.0.0",
-    "cross-env": "^7.0.3",
-    "mocha": "^10.6.0",
+    "mocha": "^10.8.2",
     "sinon": "^18.0.0",
-    "source-map-support": "^0.5.21",
     "ts-node": "^10.9.2",
-    "typescript": "^5.5.3"
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
   },
   "main": "./bin/cli.js"
 }

package/test/clilib.spec.ts

@@ -1,208 +0,0 @@
-import axios, { AxiosResponse } from "axios";
-import * as chai from "chai";
-import chaiAsPromised from "chai-as-promised";
-import fs from "fs";
-import "mocha";
-import * as sinon from "sinon";
-import clilib from "../src/clilib";
-
-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);
-  });
-});