bdy 1.16.11-master → 1.16.11-sbs-1

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.11-master",
+  "version": "1.16.11-sbs-1",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {
@@ -31,6 +31,8 @@
     "eventsource": "4.0.0",
     "fastify": "4.28.1",
     "fdir": "6.5.0",
+    "fflate": "0.8.2",
+    "human-id": "^4.1.3",
     "isbinaryfile": "5.0.2",
     "jsonwebtoken": "9.0.2",
     "mime-db": "1.52.0",
@@ -52,8 +54,7 @@
     "uuid": "10.0.0",
     "which": "4.0.0",
     "ws": "8.18.0",
-    "zod": "3.24.2",
-    "fflate": "0.8.2"
+    "zod": "3.24.2"
   },
   "devDependencies": {
     "@eslint/js": "9.13.0",

package/distTs/src/api/client.js

@@ -55,7 +55,19 @@ class ApiClient {
             throw new Error(texts_1.ERR_REST_API_WRONG_TOKEN);
         }
         if (status === 403) {
-            await responseBody.dump();
+            let json;
+            try {
+                json = await responseBody.json();
+                logger_1.default.debug('API CLIENT PARSED RESPONSE:');
+                logger_1.default.debug(json);
+            }
+            catch (err) {
+                await responseBody.dump();
+                throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
+            }
+            if (json.errors && json.errors[0] && json.errors[0].message) {
+                throw new Error(json.errors[0].message);
+            }
             throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
         }
         if ([400, 404].includes(status)) {
@@ -79,7 +91,7 @@ class ApiClient {
             else
                 throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
-        if (status === 200) {
+        if (status === 200 || status === 201) {
             if (parseResponseBody) {
                 try {
                     const b = await responseBody.json();
@@ -98,6 +110,10 @@ class ApiClient {
                 return null;
             }
         }
+        else if (status === 204) {
+            await responseBody.dump();
+            return null;
+        }
         else {
             await responseBody.dump();
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
@@ -112,5 +128,65 @@ class ApiClient {
     async postPipelineRun(workspace, project, pipelineId, body) {
         return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions`, body, true);
     }
+    // Sandbox methods
+    async createSandbox(workspace, project, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, body, true);
+    }
+    async listSandboxes(workspace, project) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, null, true);
+    }
+    async getSandbox(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, true);
+    }
+    async deleteSandbox(workspace, sandboxId) {
+        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, false);
+    }
+    async updateSandbox(workspace, sandboxId, body) {
+        return await this.request('PATCH', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, body, true);
+    }
+    async startSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/start`, {}, true);
+    }
+    async stopSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/stop`, {}, true);
+    }
+    async restartSandbox(workspace, sandboxId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/restart`, {}, true);
+    }
+    async executeSandboxCommand(workspace, sandboxId, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, body, true);
+    }
+    async getSandboxCommand(workspace, sandboxId, commandId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}`, null, true);
+    }
+    async listSandboxCommands(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, null, true);
+    }
+    async getSandboxCommandLogsUrl(workspace, sandboxId, commandId) {
+        return `${this.baseUrl.origin}/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/logs`;
+    }
+    async terminateSandboxCommand(workspace, sandboxId, commandId) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/terminate`, {}, true);
+    }
+    // Snapshot methods
+    async listSandboxSnapshots(workspace, sandboxId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, null, true);
+    }
+    async createSandboxSnapshot(workspace, sandboxId, body) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, body, true);
+    }
+    async getSandboxSnapshot(workspace, sandboxId, snapshotId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, true);
+    }
+    async deleteSandboxSnapshot(workspace, sandboxId, snapshotId) {
+        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, false);
+    }
+    // Workspace and Project methods
+    async getWorkspaces() {
+        return await this.request('GET', '/workspaces', null, true);
+    }
+    async getProjects(workspace) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects`, null, true);
+    }
 }
 exports.default = ApiClient;

package/distTs/src/command/login.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
+const cfg_1 = __importDefault(require("../tunnel/cfg"));
+const output_1 = __importDefault(require("../output"));
+const client_1 = __importDefault(require("../api/client"));
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const terminal = termkit_no_lazy_require_1.default.terminal;
+// Handle Ctrl+C and ESC
+terminal.on('key', (key) => {
+    if (key === 'CTRL_C' || key === 'ESCAPE') {
+        terminal.grabInput(false);
+        terminal('\nCanceled\n');
+        process.exit(0);
+    }
+});
+function getSecurityUrl(region, baseUrl) {
+    switch (region) {
+        case 'us':
+            return 'https://app.buddy.works/security';
+        case 'eu':
+            return 'https://eu.buddy.works/security';
+        case 'as':
+            return 'https://asia.buddy.works/security';
+        case 'onprem':
+            return `https://${baseUrl}/security`;
+    }
+}
+function getApiUrl(region, baseUrl) {
+    switch (region) {
+        case 'us':
+            return 'api.buddy.works';
+        case 'eu':
+            return 'api.eu.buddy.works';
+        case 'as':
+            return 'api.asia.buddy.works';
+        case 'onprem':
+            return `${baseUrl}/api`;
+    }
+}
+function normalizeBaseUrl(url) {
+    let normalized = url.trim();
+    normalized = normalized.replace(/^https?:\/\//i, '');
+    normalized = normalized.replace(/\/+$/, '');
+    return normalized;
+}
+async function selectRegion() {
+    terminal(`${texts_1.TXT_LOGIN_SELECT_REGION}\n`);
+    const items = ['US (default)', 'EU', 'Asia', 'On-premises'];
+    return new Promise((resolve) => {
+        terminal.singleColumnMenu(items, (error, response) => {
+            terminal('\n');
+            if (response.selectedIndex === 0)
+                resolve('us');
+            else if (response.selectedIndex === 1)
+                resolve('eu');
+            else if (response.selectedIndex === 2)
+                resolve('as');
+            else
+                resolve('onprem');
+        });
+    });
+}
+async function inputBaseUrl() {
+    terminal(`${texts_1.TXT_LOGIN_ENTER_BASE_URL} `);
+    return new Promise((resolve) => {
+        terminal.inputField((error, input) => {
+            terminal('\n');
+            const normalized = normalizeBaseUrl(input || '');
+            if (!normalized) {
+                output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_BASE_URL);
+            }
+            resolve(normalized);
+        });
+    });
+}
+async function inputToken() {
+    terminal(`${texts_1.TXT_LOGIN_ENTER_TOKEN} `);
+    return new Promise((resolve) => {
+        terminal.inputField((error, input) => {
+            terminal('\n');
+            resolve(input?.trim() || '');
+        });
+    });
+}
+async function selectWorkspace(workspaces) {
+    terminal(`${texts_1.TXT_LOGIN_SELECT_WORKSPACE}\n`);
+    const items = workspaces.map((w) => `${w.name} (${w.domain})`);
+    return new Promise((resolve) => {
+        terminal.singleColumnMenu(items, (error, response) => {
+            terminal('\n');
+            resolve(workspaces[response.selectedIndex]);
+        });
+    });
+}
+async function selectProject(projects) {
+    return new Promise((resolve) => {
+        terminal(`${texts_1.TXT_LOGIN_SELECT_PROJECT}\n`);
+        const items = ["Don't set (default)", ...projects.map((p) => `${p.display_name} (${p.name})`)];
+        // Use nextTick to ensure text is rendered before menu
+        process.nextTick(() => {
+            terminal.singleColumnMenu(items, (error, response) => {
+                terminal('\n');
+                if (response.selectedIndex === 0) {
+                    resolve(null);
+                }
+                else {
+                    resolve(projects[response.selectedIndex - 1]);
+                }
+            });
+        });
+    });
+}
+async function fetchProjects(apiUrl, token, workspace) {
+    try {
+        const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+        const response = await client.getProjects(workspace);
+        return response.projects || [];
+    }
+    catch {
+        return [];
+    }
+}
+async function verifyTokenAndGetWorkspaces(apiUrl, token) {
+    const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+    const response = await client.getWorkspaces();
+    return response.workspaces;
+}
+const commandLogin = (0, utils_1.newCommand)('login', texts_1.DESC_COMMAND_LOGIN);
+commandLogin.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandLogin.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandLogin.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandLogin.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandLogin.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandLogin.action(async (options) => {
+    try {
+        const hasToken = !!options.token;
+        const hasRegionOrApi = !!options.region || !!options.api;
+        // Non-interactive mode: token is required, region/api optional (defaults to us)
+        if (hasToken) {
+            const token = options.token;
+            let region;
+            let baseUrl;
+            let apiUrl;
+            if (options.api) {
+                region = 'onprem';
+                baseUrl = normalizeBaseUrl(options.api);
+                apiUrl = baseUrl;
+            }
+            else if (options.region?.toLowerCase() === 'eu') {
+                region = 'eu';
+                apiUrl = 'api.eu.buddy.works';
+            }
+            else if (options.region?.toLowerCase() === 'as') {
+                region = 'as';
+                apiUrl = 'api.asia.buddy.works';
+            }
+            else {
+                region = 'us';
+                apiUrl = 'api.buddy.works';
+            }
+            // Verify token
+            output_1.default.normal(texts_1.TXT_LOGIN_VERIFYING);
+            let workspaces;
+            try {
+                workspaces = await verifyTokenAndGetWorkspaces(apiUrl, token);
+            }
+            catch {
+                output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+            }
+            if (!workspaces || workspaces.length === 0) {
+                output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+            }
+            // Select workspace
+            let selectedWorkspace;
+            if (options.workspace) {
+                const found = workspaces.find((w) => w.domain === options.workspace);
+                if (!found) {
+                    output_1.default.exitError(`Workspace "${options.workspace}" not found`);
+                }
+                selectedWorkspace = found;
+            }
+            else if (workspaces.length === 1) {
+                selectedWorkspace = workspaces[0];
+            }
+            else {
+                selectedWorkspace = await selectWorkspace(workspaces);
+            }
+            // Select project (optional)
+            let selectedProject = null;
+            if (options.project) {
+                const projects = await fetchProjects(apiUrl, token, selectedWorkspace.domain);
+                const found = projects.find((p) => p.name === options.project);
+                if (found) {
+                    selectedProject = found;
+                }
+            }
+            // Save to config
+            cfg_1.default.clearLogin();
+            cfg_1.default.setToken(token);
+            cfg_1.default.setWorkspace(selectedWorkspace.domain);
+            if (selectedProject) {
+                cfg_1.default.setProject(selectedProject.name);
+            }
+            if (region === 'onprem' && baseUrl) {
+                cfg_1.default.setBaseUrl(apiUrl);
+            }
+            else {
+                cfg_1.default.setRegion(region.toUpperCase());
+            }
+            output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
+            return;
+        }
+        // Interactive mode
+        // Step 1: Select region
+        const region = await selectRegion();
+        // Step 2: Get base URL if on-premises
+        let baseUrl;
+        if (region === 'onprem') {
+            baseUrl = await inputBaseUrl();
+        }
+        // Step 3: Show token URL and ask for token
+        const securityUrl = getSecurityUrl(region, baseUrl);
+        terminal.cyan(`${(0, texts_1.TXT_LOGIN_TOKEN_INFO)(securityUrl)}\n`);
+        const token = await inputToken();
+        if (!token) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+        }
+        // Step 4: Verify token by fetching workspaces
+        terminal(`${texts_1.TXT_LOGIN_VERIFYING}\n`);
+        const apiUrl = getApiUrl(region, baseUrl);
+        let workspaces;
+        try {
+            workspaces = await verifyTokenAndGetWorkspaces(apiUrl, token);
+        }
+        catch {
+            output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_TOKEN);
+        }
+        if (!workspaces || workspaces.length === 0) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+        }
+        // Step 5: Select workspace (or auto-select if only one)
+        let selectedWorkspace;
+        if (workspaces.length === 1) {
+            selectedWorkspace = workspaces[0];
+        }
+        else {
+            selectedWorkspace = await selectWorkspace(workspaces);
+        }
+        // Step 6: Optionally select project
+        const projects = await fetchProjects(apiUrl, token, selectedWorkspace.domain);
+        let selectedProject = null;
+        if (projects.length > 0) {
+            selectedProject = await selectProject(projects);
+        }
+        // Step 7: Save to config
+        cfg_1.default.clearLogin();
+        cfg_1.default.setToken(token);
+        cfg_1.default.setWorkspace(selectedWorkspace.domain);
+        if (selectedProject) {
+            cfg_1.default.setProject(selectedProject.name);
+        }
+        if (region === 'onprem' && baseUrl) {
+            cfg_1.default.setBaseUrl(apiUrl);
+        }
+        else {
+            cfg_1.default.setRegion(region.toUpperCase());
+        }
+        output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+});
+exports.default = commandLogin;

package/distTs/src/command/logout.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../tunnel/cfg"));
+const output_1 = __importDefault(require("../output"));
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const commandLogout = (0, utils_1.newCommand)('logout', texts_1.DESC_COMMAND_LOGOUT);
+commandLogout.action(async () => {
+    cfg_1.default.clearLogin();
+    output_1.default.exitSuccess(texts_1.TXT_LOGOUT_SUCCESS);
+});
+exports.default = commandLogout;

package/distTs/src/command/package/download.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const output_1 = __importDefault(require("../../output"));
+const logger_1 = __importDefault(require("../../logger"));
+const path_1 = require("path");
+const uuid_1 = require("uuid");
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("stream/promises"));
+const fflate_1 = require("fflate");
+const commandPackageDownload = (0, utils_1.newCommand)('download', texts_1.DESC_COMMAND_PACKAGE_DOWNLOAD);
+commandPackageDownload.alias('dd');
+commandPackageDownload.option('-t, --token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandPackageDownload.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandPackageDownload.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandPackageDownload.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPackageDownload.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPackageDownload.option('-m, --merge', texts_1.OPTION_PACKAGE_DOWNLOAD_MERGE);
+commandPackageDownload.option('-r, --replace', texts_1.OPTION_PACKAGE_DOWNLOAD_REPLACE);
+commandPackageDownload.argument('<identifier>', texts_1.OPTION_PACKAGE_ID);
+commandPackageDownload.argument('<directory>', texts_1.OPTION_PACKAGE_DOWNLOAD_PATH);
+commandPackageDownload.action(async (id, path, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    const client = new client_1.default(baseUrl, token);
+    // eslint-disable-next-line prefer-const
+    let { identifier, version } = input_1.default.packageSplitIdentifier(id);
+    const data = await client.getPackageVersionByIdentifier(workspace, project, identifier, version);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (project && !data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    const packageId = data.pkg_id;
+    if (!packageId) {
+        output_1.default.exitError(texts_1.ERR_PACKAGE_DOWNLOAD_NOT_FOUND);
+    }
+    let versionId = data.pkg_version_id;
+    if (version && !versionId) {
+        output_1.default.exitError(texts_1.ERR_PACKAGE_VERSION_NOT_FOUND);
+    }
+    if (!version || !versionId) {
+        const v = await client.getPackageLatest(workspace, packageId);
+        if (!v) {
+            output_1.default.exitError(texts_1.ERR_PACKAGE_VERSION_NOT_FOUND);
+        }
+        version = v.version;
+        versionId = v.id;
+    }
+    const dirPath = (0, path_1.resolve)(path);
+    const exists = fs_1.default.existsSync(dirPath);
+    if (!exists) {
+        try {
+            fs_1.default.mkdirSync(dirPath, {
+                recursive: true,
+            });
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            output_1.default.exitError((0, texts_1.ERR_PACKAGE_DOWNLOAD_MKDIR)(dirPath));
+        }
+    }
+    else if (options.replace) {
+        try {
+            fs_1.default.rmSync(dirPath, {
+                recursive: true,
+                force: true,
+            });
+            fs_1.default.mkdirSync(dirPath, {
+                recursive: true,
+            });
+        }
+        catch (err) {
+            logger_1.default.error(err);
+            output_1.default.exitError((0, texts_1.ERR_PACKAGE_DOWNLOAD_REPLACE)(dirPath));
+        }
+    }
+    try {
+        const stat = fs_1.default.statSync(dirPath);
+        if (!stat.isDirectory()) {
+            output_1.default.exitError((0, texts_1.ERR_PACKAGE_DOWNLOAD_IS_FILE)(dirPath));
+        }
+    }
+    catch (err) {
+        logger_1.default.error(err);
+        output_1.default.exitError(texts_1.ERR_SWW);
+    }
+    let empty = true;
+    try {
+        const entries = fs_1.default.readdirSync(dirPath);
+        empty = !entries.length;
+    }
+    catch (err) {
+        logger_1.default.error(err);
+        output_1.default.exitError((0, texts_1.ERR_PACKAGE_DOWNLOAD_READDIR)(dirPath));
+    }
+    if (!empty && !options.merge) {
+        output_1.default.exitError((0, texts_1.ERR_PACKAGE_DOWNLOAD_NOT_EMPTY_DIR)(dirPath));
+    }
+    const zipPath = (0, path_1.join)((0, utils_1.getHomeDirectory)(), `${(0, uuid_1.v4)()}.zip`);
+    const clearZip = () => {
+        try {
+            fs_1.default.rmSync(zipPath);
+        }
+        catch {
+            // do nothing
+        }
+    };
+    output_1.default.normal(texts_1.TXT_PACKAGE_DOWNLOADING_ZIP);
+    const body = await client.downloadPackageVersion(workspace, packageId, versionId);
+    try {
+        await promises_1.default.pipeline(body, fs_1.default.createWriteStream(zipPath));
+        output_1.default.clearPreviousLine();
+        output_1.default.normal(texts_1.TXT_PACKAGE_DOWNLOADED_ZIP);
+        output_1.default.normal(texts_1.TXT_PACKAGE_UNZIPPING);
+        let count = 0;
+        await unzip(dirPath, zipPath, () => {
+            count += 1;
+            output_1.default.clearPreviousLine();
+            output_1.default.normal((0, texts_1.TXT_PACKAGE_UNZIPPING_COUNT)(count));
+        });
+        clearZip();
+        output_1.default.clearPreviousLine();
+        output_1.default.normal(texts_1.TXT_PACKAGE_UNZIPPED);
+    }
+    catch (err) {
+        logger_1.default.error(err);
+        clearZip();
+        output_1.default.exitError(texts_1.ERR_SWW);
+    }
+    output_1.default.exitSuccess((0, texts_1.TXT_PACKAGE_DOWNLOADED)(version, dirPath));
+});
+const unzip = (dirPath, zipPath, onFile) => {
+    return new Promise((resolve, reject) => {
+        let _startedFiles = 0;
+        let _finishedFiles = 0;
+        let _finishedStream = false;
+        let _finishedError = null;
+        let _calledResolve = false;
+        const rs = fs_1.default.createReadStream(zipPath);
+        const _finish = () => {
+            if (_finishedError || _finishedStream) {
+                try {
+                    rs.removeAllListeners();
+                    rs.close();
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (_calledResolve)
+                return;
+            if (_finishedError) {
+                _calledResolve = true;
+                reject(_finishedError);
+                return;
+            }
+            if (_finishedStream && _startedFiles === _finishedFiles) {
+                _calledResolve = true;
+                resolve();
+            }
+        };
+        const finishFile = (err, fws) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            _finishedFiles += 1;
+            if (fws) {
+                try {
+                    fws.removeAllListeners();
+                    fws.close();
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            onFile();
+            _finish();
+        };
+        const finishStream = (err) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            _finishedStream = true;
+            _finish();
+        };
+        const unzip = new fflate_1.Unzip(async (file) => {
+            if (_finishedError)
+                return;
+            _startedFiles += 1;
+            const fullPath = (0, path_1.join)(dirPath, file.name);
+            const parentPath = (0, path_1.dirname)(fullPath);
+            let fws;
+            try {
+                await fs_1.default.promises.rm(fullPath, {
+                    recursive: true,
+                    force: true,
+                });
+            }
+            catch {
+                // do nothing
+            }
+            try {
+                if (fullPath.endsWith('/')) {
+                    await fs_1.default.promises.mkdir(fullPath, {
+                        recursive: true,
+                    });
+                    finishFile();
+                    return;
+                }
+                await fs_1.default.promises.mkdir(parentPath, {
+                    recursive: true,
+                });
+                fws = fs_1.default.createWriteStream(fullPath, {
+                    flags: 'w',
+                });
+                fws.on('error', (err) => {
+                    finishFile(err, fws);
+                });
+            }
+            catch (err) {
+                finishFile(err, fws);
+                return;
+            }
+            file.ondata = (err, data, final) => {
+                if (_finishedError)
+                    return;
+                if (err)
+                    finishFile(err, fws);
+                else {
+                    if (fws)
+                        fws.write(data);
+                    if (final)
+                        finishFile(null, fws);
+                }
+            };
+            file.start();
+        });
+        unzip.register(fflate_1.AsyncUnzipInflate);
+        rs.on('data', (chunk) => {
+            unzip.push(chunk, false);
+        });
+        rs.on('error', (err) => {
+            finishStream(err);
+        });
+        rs.on('end', () => {
+            unzip.push(new Uint8Array(0), true);
+            finishStream();
+        });
+    });
+};
+exports.default = commandPackageDownload;