bdy 1.16.15-dev → 1.16.17-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.15-dev",
+  "version": "1.16.17-dev",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {
@@ -31,6 +31,7 @@
     "eventsource": "4.0.0",
     "fastify": "4.28.1",
     "fdir": "6.5.0",
+    "open": "11.0.0",
     "fflate": "0.8.2",
     "human-id": "^4.1.3",
     "isbinaryfile": "5.0.2",

package/distTs/src/api/client.js

@@ -21,18 +21,24 @@ class ApiClient {
             },
         });
     }
-    async request(method, path, body, parseResponseBody = false, rawResponseBody = false) {
-        const headers = {
-            authorization: `Bearer ${this.token}`,
-        };
+    async request(method, path, body, parseResponseBody = false, rawResponseBody = false, httpUrlEncoded = false) {
+        const headers = {};
+        if (this.token)
+            headers.authorization = `Bearer ${this.token}`;
         let bodyParsed = undefined;
         if (body) {
             if (body instanceof undici_1.FormData) {
                 bodyParsed = body;
             }
             else {
-                headers['content-type'] = 'application/json; charset=utf-8';
-                bodyParsed = JSON.stringify(body);
+                if (httpUrlEncoded) {
+                    headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+                    bodyParsed = new URLSearchParams(body).toString();
+                }
+                else {
+                    headers['content-type'] = 'application/json; charset=utf-8';
+                    bodyParsed = JSON.stringify(body);
+                }
             }
         }
         const opts = {
@@ -45,7 +51,7 @@ class ApiClient {
         let responseBody;
         logger_1.default.debug(`API CLIENT: ${method} ${this.baseUrl.protocol}//${this.baseUrl.host}${path}`);
         logger_1.default.debug(headers);
-        logger_1.default.debug(body);
+        logger_1.default.debug(bodyParsed);
         try {
             const r = await this.client.request(opts);
             status = r.statusCode;
@@ -101,7 +107,7 @@ class ApiClient {
             else
                 throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
-        if (status === 200 || status === 201) {
+        if ([200, 201].includes(status)) {
             if (parseResponseBody) {
                 try {
                     const b = await responseBody.json();
@@ -132,9 +138,6 @@ class ApiClient {
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
     }
-    async getPipelineByIdentifier(workspace, project, identifier) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/identifiers?project=${encodeURIComponent(project)}&pipeline=${encodeURIComponent(identifier)}`, null, true);
-    }
     async getPipelineRun(workspace, project, pipelineId, executionId) {
         return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(executionId)}`, null, true);
     }
@@ -172,6 +175,28 @@ class ApiClient {
     async stopSandbox(workspace, sandboxId) {
         return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/stop`, {}, true);
     }
+    async registerApp(name, redirectUrl) {
+        return await this.request('POST', '/auth/register', {
+            redirect_uris: [redirectUrl],
+            client_name: name,
+            grant_types: ['authorization_code', 'refresh_token'],
+            response_types: ['code'],
+            token_endpoint_auth_method: "client_secret_basic",
+            token_expires_in: 3600
+        }, true);
+    }
+    async getApp(clientId) {
+        return await this.request('GET', `/auth/register/${encodeURIComponent(clientId)}`, null, true);
+    }
+    async exchangeAppToken(code, clientId, clientSecret, redirectUrl) {
+        return await this.request('POST', '/oauth2/token', {
+            grant_type: 'authorization_code',
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: redirectUrl
+        }, true, false, true);
+    }
     async restartSandbox(workspace, sandboxId) {
         return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/restart`, {}, true);
     }
@@ -184,9 +209,6 @@ class ApiClient {
     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 streamSandboxCommandLogs(workspace, sandboxId, commandId, follow = true) {
         let q = '';
         if (follow)
@@ -280,8 +302,79 @@ class ApiClient {
     async getWorkspaces() {
         return await this.request('GET', '/workspaces', null, true);
     }
+    async getPackages(workspace, project) {
+        let query = '';
+        if (project)
+            query += `?project_name=${encodeURIComponent(project)}`;
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages${query}`, null, true);
+    }
     async getProjects(workspace) {
         return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects`, null, true);
     }
+    async getResourceByIdentifier(workspace, params) {
+        let query = '';
+        Object.keys(params).forEach((key) => {
+            if (!query)
+                query += '?';
+            else
+                query += '&';
+            query += encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
+        });
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/identifiers${query}`, null, true);
+    }
+    async getPipelineByIdentifier(workspace, project, identifier) {
+        return await this.getResourceByIdentifier(workspace, { project, pipeline: identifier });
+    }
+    async getPackageVersionByIdentifier(workspace, project, pkg, version) {
+        const opts = {
+            package: pkg,
+        };
+        if (project)
+            opts.project = project;
+        if (version)
+            opts.package_version = version;
+        return await this.getResourceByIdentifier(workspace, opts);
+    }
+    async getPackageVersion(workspace, pkgId, versionId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}`, null, true);
+    }
+    async getPackageLatest(workspace, pkgId) {
+        const res = await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions?page=1&per_page=1`, null, true);
+        if (res && res.versions && res.versions.length > 0) {
+            return res.versions[0];
+        }
+        return null;
+    }
+    async downloadPackageVersion(workspace, pkgId, versionId) {
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}/download`, null, false, true);
+    }
+    async postPackageVersion(workspace, pkgId, version) {
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions`, {
+            version
+        }, true);
+    }
+    async postPackageVersionZip(workspace, pkgId, versionId, file) {
+        const form = new undici_1.FormData();
+        form.append('file', file);
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${versionId}/upload`, form, true);
+    }
+    async postPackage(workspace, project, identifier) {
+        const body = {
+            name: identifier,
+            identifier,
+            type: 'FILE',
+            scope: 'WORKSPACE',
+            authorization: {
+                type: 'BUDDY'
+            }
+        };
+        if (project) {
+            body.project = {
+                name: project
+            };
+            body.scope = 'PROJECT';
+        }
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages`, body, true);
+    }
 }
 exports.default = ApiClient;

package/distTs/src/command/login.js

@@ -6,21 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cfg_1 = __importDefault(require("../tunnel/cfg"));
 const output_1 = __importDefault(require("../output"));
 const client_1 = __importDefault(require("../api/client"));
+const node_http_1 = __importDefault(require("node:http"));
+const open_1 = __importDefault(require("open"));
 const texts_1 = require("../texts");
 const utils_1 = require("../utils");
 const input_1 = __importDefault(require("../input"));
-function getSecurityUrl(region, baseUrl) {
-    switch (region) {
-        case utils_1.REST_API_REGION.US:
-            return 'https://app.buddy.works/security';
-        case utils_1.REST_API_REGION.EU:
-            return 'https://eu.buddy.works/security';
-        case utils_1.REST_API_REGION.AS:
-            return 'https://asia.buddy.works/security';
-        default:
-            return `https://${baseUrl}/security`;
-    }
-}
+const OAUTH_CLIENT_APP_PORT = 7596;
+const OAUTH_CLIENT_APP_HOST = 'localhost';
+const OAUTH_CLIENT_APP_REDIRECT_URL = `http://localhost:${OAUTH_CLIENT_APP_PORT}`;
+const OAUTH_CLIENT_APP_SCOPES = 'WORKSPACE USER_INFO EXECUTION_MANAGE SANDBOX_MANAGE PACKAGE_MANAGE';
 function normalizeBaseUrl(url) {
     let normalized = url.trim();
     normalized = normalized.replace(/^https?:\/\//i, '');
@@ -52,10 +46,104 @@ async function restApiBaseUrl() {
     }
     return `${normalized}/api`;
 }
-async function inputToken(region, baseUrl) {
-    const securityUrl = getSecurityUrl(region, baseUrl);
-    output_1.default.normal((0, texts_1.TXT_LOGIN_ENTER_TOKEN)(securityUrl));
-    return await output_1.default.inputString();
+async function oauthServer(api, clientId, clientSecret) {
+    return new Promise((resolve, reject) => {
+        const s = node_http_1.default.createServer(async (req, res) => {
+            const url = new URL(req.url || '', `http://${OAUTH_CLIENT_APP_HOST}`);
+            const urlCode = url.searchParams.get('code');
+            if (!urlCode) {
+                res.end(texts_1.ERR_LOGIN_HTTP_FAILED);
+                s.close();
+                reject(new Error(texts_1.ERR_LOGIN_HTTP_FAILED));
+                return;
+            }
+            const client = new client_1.default(new URL(`https://${api}`));
+            try {
+                const response = await client.exchangeAppToken(urlCode, clientId, clientSecret, OAUTH_CLIENT_APP_REDIRECT_URL);
+                res.end(texts_1.ERR_LOGIN_HTTP_SUCCESS);
+                s.close();
+                resolve(response.access_token);
+            }
+            catch {
+                res.end(texts_1.ERR_LOGIN_HTTP_FAILED);
+                s.close();
+                reject(new Error(texts_1.ERR_LOGIN_HTTP_FAILED));
+                return;
+            }
+        });
+        s.on('error', () => {
+            s.close();
+            reject(texts_1.ERR_LOGIN_HTTP_SERVER_PORT_TAKEN);
+        });
+        s.listen(OAUTH_CLIENT_APP_PORT, OAUTH_CLIENT_APP_HOST);
+        const url = `https://${api}/oauth2/authorize?type=web_server&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(OAUTH_CLIENT_APP_REDIRECT_URL)}&response_type=code&scope=${encodeURIComponent(OAUTH_CLIENT_APP_SCOPES)}`;
+        (0, open_1.default)(url);
+    });
+}
+async function getOrCreateApp(api) {
+    const client = new client_1.default(new URL(`https://${api}`));
+    let clientId = cfg_1.default.getApiClientId();
+    let clientSecret = cfg_1.default.getApiClientSecret();
+    if (clientId && clientSecret) {
+        let clear = false;
+        try {
+            const app = await client.getApp(clientId);
+            if (!app || !app.redirect_uris || !app.redirect_uris.includes(OAUTH_CLIENT_APP_REDIRECT_URL)) {
+                clear = true;
+            }
+        }
+        catch {
+            clear = true;
+        }
+        if (clear) {
+            clientId = null;
+            clientSecret = null;
+        }
+    }
+    if (!clientId || !clientSecret) {
+        const app = await client.registerApp('bdy cli app', OAUTH_CLIENT_APP_REDIRECT_URL);
+        clientId = app.client_id;
+        clientSecret = app.client_secret;
+        cfg_1.default.setApiClient(clientId, clientSecret);
+    }
+    return {
+        clientId,
+        clientSecret,
+    };
+}
+async function authorizeOAuth(api) {
+    const { clientId, clientSecret } = await getOrCreateApp(api);
+    return await oauthServer(api, clientId, clientSecret);
+}
+async function authorizeToken(api, token, workspace, project) {
+    const client = new client_1.default(new URL(`https://${api}`), token);
+    const w = await client.getWorkspaces();
+    if (!w.workspaces?.length) {
+        output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
+    }
+    if (workspace) {
+        const found = w.workspaces.find((w) => w.domain === workspace);
+        if (!found) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACE_FOUND);
+        }
+    }
+    else {
+        workspace = await output_1.default.selectWorkspace(w.workspaces);
+    }
+    cfg_1.default.setApiToken(token);
+    cfg_1.default.setWorkspace(workspace);
+    const p = await client.getProjects(workspace);
+    if (project) {
+        const found = p.projects.find((p) => p.name === project);
+        if (!found) {
+            output_1.default.exitError(texts_1.ERR_LOGIN_NO_PROJECT_FOUND);
+        }
+    }
+    else {
+        project = await output_1.default.selectProject(p.projects);
+    }
+    cfg_1.default.setProject(project);
+    output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
 }
 const commandLogin = (0, utils_1.newCommand)('login', texts_1.DESC_COMMAND_LOGIN);
 commandLogin.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
@@ -68,9 +156,9 @@ commandLogin.action(async (options) => {
     cfg_1.default.clearLogin();
     let api = options.api || process.env.BUDDY_API_ENDPOINT;
     let region = options.region || process.env.BUDDY_REGION;
-    let token = options.token || process.env.BUDDY_TOKEN;
-    let workspace = options.workspace || process.env.BUDDY_WORKSPACE;
-    let project = options.project || process.env.BUDDY_PROJECT;
+    const token = options.token || process.env.BUDDY_TOKEN;
+    const workspace = options.workspace || process.env.BUDDY_WORKSPACE;
+    const project = options.project || process.env.BUDDY_PROJECT;
     if (api) {
         region = utils_1.REST_API_REGION.ONPREM;
     }
@@ -96,35 +184,12 @@ commandLogin.action(async (options) => {
     }
     cfg_1.default.setBaseUrl(api);
     if (!token) {
-        token = await inputToken(region, api);
-    }
-    const client = new client_1.default(new URL(`https://${api}`), token);
-    const w = await client.getWorkspaces();
-    if (!w.workspaces?.length) {
-        output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
-    }
-    if (workspace) {
-        const found = w.workspaces.find((w) => w.domain === workspace);
-        if (!found) {
-            output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACE_FOUND);
-        }
-    }
-    else {
-        workspace = await output_1.default.selectWorkspace(w.workspaces);
-    }
-    cfg_1.default.setApiToken(token);
-    cfg_1.default.setWorkspace(workspace);
-    const p = await client.getProjects(workspace);
-    if (project) {
-        const found = p.projects.find((p) => p.name === project);
-        if (!found) {
-            output_1.default.exitError(texts_1.ERR_LOGIN_NO_PROJECT_FOUND);
-        }
+        output_1.default.normal(texts_1.TXT_LOGIN_OAUTH);
+        const token = await authorizeOAuth(api);
+        await authorizeToken(api, token, workspace, project);
     }
     else {
-        project = await output_1.default.selectProject(p.projects);
+        await authorizeToken(api, token, workspace, project);
     }
-    cfg_1.default.setProject(project);
-    output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
 });
 exports.default = commandLogin;

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;

package/distTs/src/command/package/list.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_1 = __importDefault(require("../../output"));
+const client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const input_1 = __importDefault(require("../../input"));
+const commandPackageList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_PACKAGE_LIST);
+commandPackageList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandPackageList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandPackageList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandPackageList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPackageList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPackageList.alias('ls');
+commandPackageList.action(async (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);
+    const response = await client.getPackages(workspace, project);
+    if (!response.packages || response.packages.length === 0) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_PACKAGE_NO_PROJECTS);
+    }
+    const data = [['NAME', 'IDENTIFIER']];
+    for (const pkg of response.packages) {
+        data.push([pkg.name, pkg.identifier]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandPackageList;