defang 0.5.21 → 0.5.26

package/bin/cli.js

@@ -1,9 +1,176 @@
 #!/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 path = require("path");
-const child_process = require("child_process");
+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)) {
@@ -14,13 +181,75 @@ function getPathToExecutable() {
         return require.resolve(executablePath);
     }
     catch (e) {
-        throw new Error(`Could not find application binary at ${executablePath}.`);
+        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 };
 }
-function run() {
+async function run() {
     try {
-        const args = process.argv.slice(2);
-        const processResult = child_process.spawnSync(getPathToExecutable(), args, {
+        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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "defang",
-  "version": "0.5.21",
+  "version": "0.5.26",
   "author": "Defang Software Labs Inc.",
   "description": "CLI for the Defang Opinionated Platform",
   "license": "MIT",
@@ -17,11 +17,10 @@
     "url": "https://github.com/DefangLabs/defang/issues"
   },
   "scripts": {
-    "build": "tsc",
-    "postinstall": "node ./bin/installer.js"
+    "build": "tsc"
   },
   "dependencies": {
-    "adm-zip": "^0.5.12",
+    "adm-zip": "^0.5.14",
     "axios": "^1.6.8",
     "https": "^1.0.0",
     "os": "^0.1.2",

package/bin/installer.js

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const os = require("os");
-const path = require("path");
-const tar = require("tar");
-const AdmZip = require("adm-zip");
-const axios_1 = require("axios");
-const fs_1 = require("fs");
-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 downloadFile(downloadUrl, downloadTargetFile);
-}
-async function downloadFile(downloadUrl, downloadTargetFile) {
-    try {
-        console.log(`Downloading ${downloadUrl}`);
-        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 "";
-    }
-}
-function extractArchive(archiveFilePath, outputPath) {
-    let result = false;
-    console.log(`Extracting ${archiveFilePath}`);
-    const ext = path.extname(archiveFilePath).toLocaleLowerCase();
-    switch (ext) {
-        case ".zip":
-            result = extractZip(archiveFilePath, outputPath);
-            break;
-        case ".gz":
-            result = extractTarGz(archiveFilePath, outputPath);
-            break;
-        default:
-            throw new Error(`Unsupported archive extension: ${ext}`);
-    }
-    return result;
-}
-function extractZip(zipPath, outputPath) {
-    try {
-        const zip = new AdmZip(zipPath);
-        zip.extractAllTo(outputPath, true, true);
-        return true;
-    }
-    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,
-        });
-        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() {
-    try {
-        console.log(`Starting install of defang cli`);
-        const version = await getVersion("package.json");
-        const filename = getAppArchiveFilename(version, os.platform(), os.arch());
-        const archiveFile = await downloadAppArchive(version, filename, __dirname);
-        if (archiveFile.length === 0) {
-            throw new Error(`Failed to download ${filename}`);
-        }
-        const result = extractArchive(archiveFile, "./bin");
-        if (result === false) {
-            throw new Error(`Failed to install binaries!`);
-        }
-        console.log(`Successfully installed defang cli!`);
-        await deleteArchive(archiveFile);
-    }
-    catch (error) {
-        console.error(error);
-    }
-}
-install();