bdy 1.16.12 → 1.16.14-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.12",
+  "version": "1.16.14-dev",
   "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

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const undici_1 = require("undici");
 const texts_1 = require("../texts");
 const logger_1 = __importDefault(require("../logger"));
+const utils_1 = require("../utils");
+const node_fs_1 = __importDefault(require("node:fs"));
 class ApiClient {
     client;
     token;
@@ -19,14 +21,19 @@ class ApiClient {
             },
         });
     }
-    async request(method, path, body, parseResponseBody = false) {
+    async request(method, path, body, parseResponseBody = false, rawResponseBody = false) {
         const headers = {
             authorization: `Bearer ${this.token}`,
         };
         let bodyParsed = undefined;
         if (body) {
-            headers['content-type'] = 'application/json; charset=utf-8';
-            bodyParsed = JSON.stringify(body);
+            if (body instanceof undici_1.FormData) {
+                bodyParsed = body;
+            }
+            else {
+                headers['content-type'] = 'application/json; charset=utf-8';
+                bodyParsed = JSON.stringify(body);
+            }
         }
         const opts = {
             method,
@@ -48,6 +55,9 @@ class ApiClient {
         catch (err) {
             logger_1.default.debug('API CLIENT RESPONSE ERROR');
             logger_1.default.debug(err);
+            if (/ECONNREFUSED|ECONNRESET|ETIMEDOUT/.test(err.message)) {
+                throw new Error(texts_1.ERR_REST_API_CONNECT_ERROR);
+            }
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
         if (status === 401) {
@@ -55,7 +65,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 {
+                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 +101,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();
@@ -93,11 +115,18 @@ class ApiClient {
                     throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
                 }
             }
+            else if (rawResponseBody) {
+                return responseBody;
+            }
             else {
                 await responseBody.dump();
                 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 +141,144 @@ 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 sandboxUploadFile(workspace, sandboxId, remotePath, localPath) {
+        const formData = new undici_1.FormData();
+        const file = await node_fs_1.default.openAsBlob(localPath);
+        formData.set('file', file);
+        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/content/upload${remotePath}`, formData, 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 streamSandboxCommandLogs(workspace, sandboxId, commandId, follow = true) {
+        let q = '';
+        if (follow)
+            q = '?follow=true';
+        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/logs${q}`, null, false, true);
+    }
+    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);
+    }
+    async sandboxWaitForSnapshot(workspace, sandboxId, snapshotId, timeout = 300) {
+        const end = Date.now() + timeout * 1000;
+        for (;;) {
+            const sb = await this.getSandboxSnapshot(workspace, sandboxId, snapshotId);
+            if ([
+                utils_1.SANDBOX_SNAPSHOT_STATUS.FAILED,
+                utils_1.SANDBOX_SNAPSHOT_STATUS.CREATED,
+            ].includes(sb.status)) {
+                return sb.status;
+            }
+            if (Date.now() > end) {
+                throw new Error('timeout');
+            }
+            await this.waitSleep();
+        }
+    }
+    async sandboxWaitForRunning(workspace, sandboxId, timeout = 300) {
+        const end = Date.now() + timeout * 1000;
+        for (;;) {
+            const sb = await this.getSandbox(workspace, sandboxId);
+            if ([
+                utils_1.SANDBOX_STATUS.FAILED,
+                utils_1.SANDBOX_STATUS.RUNNING,
+                utils_1.SANDBOX_STATUS.STOPPED,
+            ].includes(sb.status)) {
+                return sb.status;
+            }
+            if (Date.now() > end) {
+                throw new Error('timeout');
+            }
+            await this.waitSleep();
+        }
+    }
+    async waitSleep(timeout = 3) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, timeout * 1000);
+        });
+    }
+    async sandboxWaitForConfigured(workspace, sandboxId, timeout = 300) {
+        const end = Date.now() + timeout * 1000;
+        for (;;) {
+            const sb = await this.getSandbox(workspace, sandboxId);
+            if ([utils_1.SANDBOX_SETUP_STATUS.SUCCESS, utils_1.SANDBOX_SETUP_STATUS.FAILED].includes(sb.setup_status)) {
+                return sb.setup_status;
+            }
+            if (Date.now() > end) {
+                throw new Error('timeout');
+            }
+            await this.waitSleep();
+        }
+    }
+    async sandboxWaitForApp(workspace, sandboxId, timeout = 300) {
+        const end = Date.now() + timeout * 1000;
+        for (;;) {
+            const sb = await this.getSandbox(workspace, sandboxId);
+            if ([
+                utils_1.SANDBOX_APP_STATUS.RUNNING,
+                utils_1.SANDBOX_APP_STATUS.FAILED,
+                utils_1.SANDBOX_APP_STATUS.ENDED,
+            ].includes(sb.app_status)) {
+                return sb.app_status;
+            }
+            if (Date.now() > end) {
+                throw new Error('timeout');
+            }
+            await this.waitSleep();
+        }
+    }
+    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,130 @@
+"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 client_1 = __importDefault(require("../api/client"));
+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`;
+    }
+}
+function normalizeBaseUrl(url) {
+    let normalized = url.trim();
+    normalized = normalized.replace(/^https?:\/\//i, '');
+    normalized = normalized.replace(/\/+$/, '');
+    return normalized;
+}
+async function selectRegion() {
+    output_1.default.normal(texts_1.TXT_LOGIN_SELECT_REGION);
+    const index = await output_1.default.inputMenu([
+        'US (default)',
+        'EU',
+        'Asia',
+        'On-premises',
+    ]);
+    if (index === 0)
+        return utils_1.REST_API_REGION.US;
+    if (index === 1)
+        return utils_1.REST_API_REGION.EU;
+    if (index === 2)
+        return utils_1.REST_API_REGION.AS;
+    return utils_1.REST_API_REGION.ONPREM;
+}
+async function restApiBaseUrl() {
+    output_1.default.normal(texts_1.TXT_LOGIN_ENTER_BASE_URL);
+    const str = await output_1.default.inputString();
+    const normalized = normalizeBaseUrl(str);
+    if (!normalized) {
+        output_1.default.exitError(texts_1.ERR_LOGIN_INVALID_BASE_URL);
+    }
+    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();
+}
+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) => {
+    output_1.default.handleSignals();
+    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;
+    if (api) {
+        region = utils_1.REST_API_REGION.ONPREM;
+    }
+    else if (region) {
+        region = input_1.default.restApiRegion(region);
+    }
+    else {
+        region = await selectRegion();
+    }
+    if (!api) {
+        if (region === utils_1.REST_API_REGION.ONPREM) {
+            api = await restApiBaseUrl();
+        }
+        else if (region === utils_1.REST_API_REGION.AS) {
+            api = utils_1.REST_API_ENDPOINT.AS;
+        }
+        else if (region === utils_1.REST_API_REGION.EU) {
+            api = utils_1.REST_API_ENDPOINT.EU;
+        }
+        else {
+            api = utils_1.REST_API_ENDPOINT.US;
+        }
+    }
+    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);
+        }
+    }
+    else {
+        project = await output_1.default.selectProject(p.projects);
+    }
+    cfg_1.default.setProject(project);
+    output_1.default.exitSuccess(texts_1.TXT_LOGIN_SUCCESS);
+});
+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/project/get.js

@@ -0,0 +1,18 @@
+"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 commandProjectGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_PROJECT_GET);
+commandProjectGet.action(async () => {
+    const project = cfg_1.default.getProject();
+    if (!project) {
+        output_1.default.exitError(texts_1.TXT_PROJECT_NONE);
+    }
+    output_1.default.exitNormal(project);
+});
+exports.default = commandProjectGet;

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

@@ -0,0 +1,33 @@
+"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 commandProjectList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_PROJECT_LIST);
+commandProjectList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandProjectList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandProjectList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandProjectList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandProjectList.alias('ls');
+commandProjectList.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 client = new client_1.default(baseUrl, token);
+    const response = await client.getProjects(workspace);
+    if (!response.projects || response.projects.length === 0) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NO_PROJECTS);
+    }
+    const data = [['NAME', 'DISPLAY NAME', 'STATUS']];
+    for (const proj of response.projects) {
+        data.push([proj.name, proj.display_name, proj.status]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandProjectList;

package/distTs/src/command/project/set.js

@@ -0,0 +1,45 @@
+"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 client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const input_1 = __importDefault(require("../../input"));
+const commandProjectSet = (0, utils_1.newCommand)('set', texts_1.DESC_COMMAND_PROJECT_SET);
+commandProjectSet.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandProjectSet.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandProjectSet.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandProjectSet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandProjectSet.argument('[project]', texts_1.ARG_COMMAND_PROJECT_NAME);
+commandProjectSet.action(async (projectName, options) => {
+    output_1.default.handleSignals();
+    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 client = new client_1.default(baseUrl, token);
+    const response = await client.getProjects(workspace);
+    if (!response.projects || response.projects.length === 0) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NO_PROJECTS);
+    }
+    let project;
+    if (projectName) {
+        const found = response.projects.find((p) => p.name === projectName);
+        if (!found) {
+            output_1.default.exitError((0, texts_1.ERR_PROJECT_NOT_FOUND)(projectName));
+        }
+        project = found.name;
+    }
+    else {
+        project = await output_1.default.selectProject(response.projects);
+    }
+    cfg_1.default.setProject(project);
+    if (!project)
+        output_1.default.exitSuccess(texts_1.TXT_PROJECT_SET_CLEARED);
+    else
+        output_1.default.exitSuccess((0, texts_1.TXT_PROJECT_SET_SUCCESS)(project));
+});
+exports.default = commandProjectSet;

package/distTs/src/command/project.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const list_1 = __importDefault(require("./project/list"));
+const set_1 = __importDefault(require("./project/set"));
+const get_1 = __importDefault(require("./project/get"));
+const commandProject = (0, utils_1.newCommand)('project', texts_1.DESC_COMMAND_PROJECT);
+commandProject.alias('proj');
+commandProject.addCommand(list_1.default);
+commandProject.addCommand(set_1.default);
+commandProject.addCommand(get_1.default);
+exports.default = commandProject;

package/distTs/src/command/sandbox/cp.js

@@ -0,0 +1,71 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const fdir_1 = require("fdir");
+const path_1 = require("path");
+const commandSandboxCp = (0, utils_1.newCommand)('cp', texts_1.DESC_COMMAND_SANDBOX_CP);
+commandSandboxCp.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCp.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCp.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCp.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCp.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCp.option('-s, --silent', texts_1.OPTION_SANDBOX_CP_SILENT);
+commandSandboxCp.argument('<source>', texts_1.OPTION_SANDBOX_CP_SOURCE);
+commandSandboxCp.argument('<destination>', texts_1.OPTION_SANDBOX_CP_DEST);
+commandSandboxCp.action(async (source, destination, 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);
+    const client = new client_1.default(baseUrl, token);
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const { identifier, remotePath } = input_1.default.restApiSandboxDestinationPath(destination);
+    const { sourcePath, sourceStats } = input_1.default.restApiSandboxSourcePath(source);
+    const silent = options.silent;
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    if (sourceStats.isFile()) {
+        // Single file copy
+        if (!silent) {
+            output_1.default.gray((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(1, 1, (0, path_1.basename)(sourcePath)));
+        }
+        await client.sandboxUploadFile(workspace, found.id, remotePath, sourcePath);
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(1));
+    }
+    else if (sourceStats.isDirectory()) {
+        // Directory copy - get all files recursively
+        const files = new fdir_1.fdir()
+            .withFullPaths()
+            .crawl(sourcePath)
+            .sync();
+        if (files.length === 0) {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(0));
+        }
+        if (!silent)
+            output_1.default.normal(`Copying ${files.length} file(s)...`);
+        for (let i = 0; i < files.length; i++) {
+            const localFile = files[i];
+            const relativePath = (0, path_1.relative)(sourcePath, localFile);
+            const remoteFile = (0, path_1.join)(remotePath, relativePath).replace(/\\/g, '/');
+            if (!silent) {
+                output_1.default.gray((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(i + 1, files.length, relativePath));
+            }
+            await client.sandboxUploadFile(workspace, found.id, remoteFile, localFile);
+        }
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(files.length));
+    }
+    else {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_CP_SOURCE_NOT_FOUND)(source));
+    }
+});
+exports.default = commandSandboxCp;