bdy 1.23.13 → 1.23.14-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.23.13",
+  "version": "1.23.14-dev",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",
@@ -27,6 +27,8 @@
     "e2e:tunnel": "vitest run --config e2e/vitest.config.ts e2e/modules/tunnel/",
     "e2e:agent": "vitest run --config e2e/vitest.config.ts e2e/modules/agent/",
     "e2e:distro": "vitest run --config e2e/vitest.config.ts e2e/modules/distro/",
+    "e2e:target": "vitest run --config e2e/vitest.config.ts e2e/modules/target/",
+    "e2e:environment": "vitest run --config e2e/vitest.config.ts e2e/modules/environment/",
     "unit": "vitest run --config vitest.config.ts"
   },
   "files": [

package/distTs/src/api/client.js

@@ -16,6 +16,25 @@ const cfg_1 = __importDefault(require("../tunnel/cfg"));
  * echo back the escaped form - callers comparing a response against the names
  * they passed in must apply the same mapping.
  */
+const RETRIABLE_NETWORK_ERROR = /ECONNREFUSED|ECONNRESET|ETIMEDOUT/;
+// undici headers can be string | string[]; callers want the first value.
+const headerValue = (h) => Array.isArray(h) ? h[0] : h;
+// How long to wait before retrying a transient status on an idempotent
+// request, or null when a retry makes no sense (non-retriable status, or a
+// rate limit window that resets too far in the future to wait for).
+const retryDelay = (status, attempt, rateLimitReset) => {
+    if (status === 429) {
+        if (!rateLimitReset)
+            return null;
+        const ms = parseInt(rateLimitReset, 10) * 1000 - Date.now();
+        if (ms <= 0)
+            return 1000;
+        return ms > 15000 ? null : ms + 500;
+    }
+    return [502, 503, 504].includes(status) ? attempt * 1000 : null;
+};
+const RATE_LIMIT_WARN_THRESHOLD = 25;
+let rateLimitWarned = false;
 const formDataFileName = (name) => name.replace(/["\r\n]/g, (c) => ({ '"': '%22', '\r': '%0D', '\n': '%0A' })[c]);
 exports.formDataFileName = formDataFileName;
 class ApiClient {
@@ -67,9 +86,8 @@ class ApiClient {
         }
         return false;
     }
-    async request({ method = 'GET', path, query, body = null, headers = {}, parseResponseBody = false, rawResponseBody = false, rawResponse = false, httpUrlEncoded = false, tryRefreshingToken = true, }) {
-        if (!headers)
-            headers = {};
+    async request(args) {
+        const { method = 'GET', path, query, body = null, headers = {}, parseResponseBody = false, rawResponseBody = false, rawResponse = false, httpUrlEncoded = false, tryRefreshingToken = true, } = args;
         if (this.token && !headers.authorization) {
             headers.authorization = `Bearer ${this.token}`;
         }
@@ -112,20 +130,41 @@ class ApiClient {
         logger_1.default.debug(headers);
         logger_1.default.debug('BODY');
         logger_1.default.debug(bodyParsed);
-        try {
-            response = await this.client.request(opts);
-            rateLimitReset = response.headers['x-rate-limit-reset'];
+        // Transient failures (rate limit with a nearby reset, 5xx, connection
+        // resets) are retried with a backoff, but only for idempotent requests -
+        // retrying a POST could duplicate the operation.
+        const maxAttempts = method === 'GET' ? 3 : 1;
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                response = await this.client.request(opts);
+            }
+            catch (err) {
+                logger_1.default.debug('API CLIENT RESPONSE ERROR');
+                logger_1.default.debug(err);
+                const retriable = RETRIABLE_NETWORK_ERROR.test(err.message);
+                if (retriable && attempt < maxAttempts) {
+                    await (0, utils_1.sleep)(attempt * 1000);
+                    continue;
+                }
+                throw new Error(retriable ? texts_1.ERR_REST_API_CONNECT_ERROR : texts_1.ERR_REST_API_GENERAL_ERROR, { cause: err });
+            }
+            rateLimitReset = headerValue(response.headers['x-rate-limit-reset']);
             status = response.statusCode;
             responseBody = response.body;
             logger_1.default.debug(`API CLIENT RESPONSE STATUS: ${status}`);
+            const delay = attempt < maxAttempts
+                ? retryDelay(status, attempt, rateLimitReset)
+                : null;
+            if (delay === null)
+                break;
+            await responseBody.dump();
+            logger_1.default.debug(`API CLIENT RETRY IN ${delay}ms`);
+            await (0, utils_1.sleep)(delay);
         }
-        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, { cause: err });
-            }
-            throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR, { cause: err });
+        this.warnRateLimitLow(headerValue(response.headers['x-rate-limit-remaining']), rateLimitReset);
+        if (status === 429) {
+            await responseBody.dump();
+            throw new Error((0, texts_1.ERR_REST_API_RATE_LIMIT)(rateLimitReset));
         }
         if (status === 401) {
             await responseBody.dump();
@@ -136,15 +175,12 @@ class ApiClient {
                 const success = await this.tryRefreshToken();
                 if (success) {
                     delete headers.authorization;
+                    // Retry with the complete original args (an explicit field list
+                    // once silently dropped `query` here); only the mutated headers
+                    // and the refresh guard are overridden.
                     return await this.request({
-                        method,
-                        path,
-                        body,
+                        ...args,
                         headers,
-                        parseResponseBody,
-                        rawResponseBody,
-                        rawResponse,
-                        httpUrlEncoded,
                         tryRefreshingToken: false,
                     });
                 }
@@ -185,7 +221,7 @@ class ApiClient {
             if (status === 404)
                 throw new Error(texts_1.ERR_REST_API_RESOURCE_NOT_FOUND);
             else
-                throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
+                throw new Error((0, texts_1.ERR_REST_API_HTTP_ERROR)(status));
         }
         if ([200, 201].includes(status)) {
             if (parseResponseBody) {
@@ -213,6 +249,12 @@ class ApiClient {
             }
         }
         else if (status === 204) {
+            // A no-content success still honors the raw-output contracts: callers
+            // stream the (empty) body instead of tripping over a null.
+            if (rawResponse)
+                return response;
+            if (rawResponseBody)
+                return responseBody;
             await responseBody.dump();
             return null;
         }
@@ -220,10 +262,38 @@ class ApiClient {
             throw new Error(texts_1.ERR_REST_API_NOT_RESPONDING);
         }
         else {
-            await responseBody.dump();
-            throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
+            // Any other error status (409, 422, 5xx...): surface the API's own
+            // message when the body carries one (e.g. "Concurrency limit reached")
+            // instead of reducing it to a bare HTTP code.
+            let json;
+            try {
+                json = await responseBody.json();
+            }
+            catch {
+                throw new Error((0, texts_1.ERR_REST_API_HTTP_ERROR)(status));
+            }
+            logger_1.default.debug('API CLIENT PARSED RESPONSE:');
+            logger_1.default.debug(json);
+            if (json.errors && json.errors[0] && json.errors[0].message) {
+                throw new Error((0, texts_1.ERR_API_MESSAGE_REPLACER)(json.errors[0].message, path, this.baseUrl, rateLimitReset));
+            }
+            throw new Error((0, texts_1.ERR_REST_API_HTTP_ERROR)(status));
         }
     }
+    // Set by the CLI bootstrap (Input.restApiTokenClient); the transport layer
+    // only detects the condition and leaves rendering to the caller, so
+    // non-interactive consumers (MCP proxy) stay silent.
+    static onRateLimitLow;
+    // One-time notification when the rate limit window is nearly exhausted.
+    warnRateLimitLow(remaining, reset) {
+        if (rateLimitWarned || !remaining || !ApiClient.onRateLimitLow)
+            return;
+        const left = parseInt(remaining, 10);
+        if (Number.isNaN(left) || left > RATE_LIMIT_WARN_THRESHOLD)
+            return;
+        rateLimitWarned = true;
+        ApiClient.onRateLimitLow(remaining, reset);
+    }
     async getPipelineRunActionLogs(workspace, project, pipelineId, executionId, actionExecutionId, offset, limit) {
         const query = {
             offset: String(offset),
@@ -563,6 +633,162 @@ class ApiClient {
             q.project = project;
         return await this.getResourceByIdentifier(workspace, q);
     }
+    // Target methods
+    targetScopeQuery(scope) {
+        const query = {};
+        if (scope.project)
+            query.project_name = scope.project;
+        if (scope.pipelineId)
+            query.pipeline_id = scope.pipelineId.toString();
+        if (scope.environmentId)
+            query.environment_id = scope.environmentId;
+        return query;
+    }
+    async getTargets(workspace, filters = {}) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets`,
+            query: this.targetScopeQuery(filters),
+            parseResponseBody: true,
+        });
+    }
+    async getTarget(workspace, targetId) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}`,
+            parseResponseBody: true,
+        });
+    }
+    async createTargetByYaml(workspace, scope, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/yaml`,
+            query: this.targetScopeQuery(scope),
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async updateTargetByYaml(workspace, targetId, body) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/yaml`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async deleteTarget(workspace, targetId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async executeTargetCommand(workspace, targetId, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetExecs(workspace, targetId, limit) {
+        const query = {};
+        if (limit)
+            query.limit = limit.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetExec(workspace, execId, wait) {
+        const query = {};
+        if (wait)
+            query.wait = wait.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async cancelTargetExec(workspace, execId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async getTargetExecLog(workspace, execId, offset, limit) {
+        const query = {};
+        if (offset)
+            query.offset = offset.toString();
+        if (limit)
+            query.limit = limit.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}/log`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetByIdentifier(workspace, identifier, line = {}) {
+        return await this.getResourceByIdentifier(workspace, {
+            target: identifier,
+            ...line,
+        });
+    }
+    // Environment methods
+    async getEnvironments(workspace, project) {
+        const query = {};
+        if (project)
+            query.project_name = project;
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getEnvironment(workspace, environmentId) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            parseResponseBody: true,
+        });
+    }
+    async createEnvironment(workspace, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async updateEnvironment(workspace, environmentId, body) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async deleteEnvironment(workspace, environmentId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async getEnvironmentByIdentifier(workspace, identifier, project) {
+        const q = {
+            environment: identifier,
+        };
+        if (project)
+            q.project = project;
+        return await this.getResourceByIdentifier(workspace, q);
+    }
     // Sandbox methods
     async createSandbox(workspace, project, body) {
         return await this.request({
@@ -1027,11 +1253,20 @@ class ApiClient {
                 query += '&';
             query += encodeURIComponent(key) + '=' + encodeURIComponent(value);
         });
-        return await this.request({
+        const resolved = await this.request({
             method: 'GET',
             path: `/workspaces/${encodeURIComponent(workspace)}/identifiers${query}`,
             parseResponseBody: true,
         });
+        // A queried project must itself resolve: for some resources
+        // (environments, artifacts, distributions) the endpoint otherwise falls
+        // back to the workspace resource of the same identifier, silently
+        // answering for a different scope than asked (TARGET_API_REQUIREMENTS.md
+        // p6). project_identifier is present whenever the project exists.
+        if (params.project && !resolved.project_identifier) {
+            throw new Error(texts_1.ERR_PROJECT_NOT_FOUND);
+        }
+        return resolved;
     }
     async resolveIdentifiers(workspace, params) {
         let query = '';

package/distTs/src/cliIndex.js

@@ -24,6 +24,8 @@ const artifact_1 = __importDefault(require("./command/artifact"));
 const api_1 = __importDefault(require("./command/api"));
 const domain_1 = __importDefault(require("./command/domain"));
 const distro_1 = __importDefault(require("./command/distro"));
+const target_1 = __importDefault(require("./command/target"));
+const environment_1 = __importDefault(require("./command/environment"));
 const register_1 = __importDefault(require("./command/register"));
 const mcp_1 = __importDefault(require("./command/mcp"));
 function cliIndex() {
@@ -47,6 +49,8 @@ function cliIndex() {
     program.addCommand(sandbox_1.default);
     program.addCommand(domain_1.default);
     program.addCommand(distro_1.default);
+    program.addCommand(target_1.default);
+    program.addCommand(environment_1.default);
     program.addCommand(login_1.default);
     program.addCommand(register_1.default);
     program.addCommand(whoami_1.default);

package/distTs/src/command/api/request.js

@@ -159,14 +159,15 @@ const request = async (method, url, options) => {
         output_1.default.exitNormal('');
     }
     else {
-        // setEncoding keeps multibyte characters intact across chunk boundaries,
-        // and newLine=false keeps chunk boundaries out of the payload
+        // setEncoding keeps multibyte characters intact across chunk boundaries;
+        // the response is a 1:1 payload, so it bypasses terminal-kit (whose
+        // formatting corrupts % and ^ sequences, common in URL-encoded data)
         body.setEncoding('utf8');
         body.on('data', (data) => {
-            output_1.default.normal(data, false);
+            output_1.default.data(data, false);
         });
         body.on('close', () => {
-            output_1.default.normal('');
+            output_1.default.data('');
             output_1.default.exitNormal('');
         });
     }

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

@@ -18,14 +18,12 @@ commandArtifactList.action(async (options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const project = input_1.default.restApiProject(options.project, true);
     const scope = input_1.default.scope(project, options.scope);
+    input_1.default.projectScopeNote(options, project, scope, 'artifacts');
     const client = input_1.default.restApiTokenClient();
     const response = await client.getArtifacts(workspace, scope === distro_1.SCOPE.PROJECT ? project : null);
     const artifacts = response.artifacts || [];
     if (options.format === 'json') {
-        const filtered = scope === distro_1.SCOPE.PROJECT
-            ? artifacts.filter((a) => a.scope !== distro_1.SCOPE.WORKSPACE)
-            : artifacts;
-        output_1.default.json(filtered);
+        output_1.default.json(artifacts);
     }
     else {
         if (artifacts.length === 0) {
@@ -33,8 +31,6 @@ commandArtifactList.action(async (options) => {
         }
         const data = [['NAME', 'IDENTIFIER', 'TYPE', 'URL']];
         for (const artifact of artifacts) {
-            if (scope === distro_1.SCOPE.PROJECT && artifact.scope === distro_1.SCOPE.WORKSPACE)
-                continue;
             data.push([
                 artifact.name,
                 artifact.identifier,

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

@@ -19,6 +19,7 @@ commandDistroList.action(async (options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const project = input_1.default.restApiProject(options.project, true);
     const scope = input_1.default.scope(project, options.scope);
+    input_1.default.projectScopeNote(options, project, scope, 'distributions');
     const client = input_1.default.restApiTokenClient();
     const r = await client.getDistributions(workspace, scope === distro_1.SCOPE.PROJECT ? project : null);
     const distributions = r.distributions || [];

package/distTs/src/command/distro/route/update.js

@@ -77,7 +77,7 @@ commandDistroRouteUpdate.action(async (identifier, routeId, options) => {
         changed = true;
     }
     if (!changed) {
-        output_1.default.exitError(texts_1.ERR_COMMAND_ROUTE_NO_UPDATE);
+        output_1.default.exitError(texts_1.ERR_COMMAND_NO_UPDATE);
     }
     const result = await client.updateRoute(workspace, scope === distro_1.SCOPE.PROJECT ? project : null, data.distribution_id, routeId, body);
     output_1.default.id(result.id);

package/distTs/src/command/distro/update.js

@@ -27,14 +27,6 @@ commandDistroUpdate.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const project = input_1.default.restApiProject(options.project, true);
     const scope = input_1.default.scope(project, options.scope);
-    const client = input_1.default.restApiTokenClient();
-    const data = await client.getDistributionByIdentifier(workspace, scope === distro_1.SCOPE.PROJECT ? project : null, identifier);
-    if (!data || !data.domain) {
-        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
-    }
-    if (!data || !data.distribution_id) {
-        output_1.default.exitError(texts_1.ERR_COMMAND_DISTRO_NOT_FOUND);
-    }
     const body = {};
     let changed = false;
     if (options.name) {
@@ -54,7 +46,15 @@ commandDistroUpdate.action(async (identifier, options) => {
         changed = true;
     }
     if (!changed) {
-        output_1.default.exitError(texts_1.ERR_COMMAND_DISTRO_NO_UPDATE);
+        output_1.default.exitError(texts_1.ERR_COMMAND_NO_UPDATE);
+    }
+    const client = input_1.default.restApiTokenClient();
+    const data = await client.getDistributionByIdentifier(workspace, scope === distro_1.SCOPE.PROJECT ? project : null, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data || !data.distribution_id) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_DISTRO_NOT_FOUND);
     }
     const result = await client.updateDistribution(workspace, scope === distro_1.SCOPE.PROJECT ? project : null, data.distribution_id, body);
     output_1.default.identifier(result.identifier);

package/distTs/src/command/environment/create.js

@@ -0,0 +1,70 @@
+"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 output_1 = __importDefault(require("../../output"));
+const distro_1 = require("../../types/distro");
+const commandEnvironmentCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_ENVIRONMENT_CREATE);
+commandEnvironmentCreate.alias('add');
+commandEnvironmentCreate.option('-i, --identifier <identifier>', texts_1.OPTION_ENVIRONMENT_CREATE_IDENTIFIER);
+commandEnvironmentCreate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandEnvironmentCreate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandEnvironmentCreate.option('--scope <scope>', texts_1.OPT_COMMAND_SCOPE);
+commandEnvironmentCreate.option('--tags <tags>', texts_1.OPTION_ENVIRONMENT_TAGS);
+commandEnvironmentCreate.option('--public-url <url>', texts_1.OPTION_ENVIRONMENT_PUBLIC_URL);
+commandEnvironmentCreate.option('--icon <icon>', texts_1.OPTION_ENVIRONMENT_ICON);
+commandEnvironmentCreate.option('--note <note>', texts_1.OPT_COMMAND_NOTE);
+commandEnvironmentCreate.option('--agent-note <note>', texts_1.OPT_COMMAND_AGENT_NOTE);
+commandEnvironmentCreate.argument('[name]', texts_1.OPTION_ENVIRONMENT_NAME);
+commandEnvironmentCreate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_ENVIRONMENT_CREATE}`);
+commandEnvironmentCreate.action(async (name, options) => {
+    const humanId = require('human-id').default;
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    const scope = input_1.default.scope(project, options.scope);
+    if (!name) {
+        if (options.identifier)
+            name = options.identifier;
+        else
+            name = humanId({ separator: '-', capitalize: false });
+    }
+    // identifier is required by the API; derive a slug from the name when
+    // -i is not given (hyphens cannot appear at the start or end)
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const data = {
+        name,
+        identifier: options.identifier || slug,
+        scope,
+    };
+    if (project && scope === distro_1.SCOPE.PROJECT) {
+        data.project = {
+            name: project,
+        };
+    }
+    if (options.tags) {
+        data.tags = input_1.default.tags(options.tags);
+    }
+    if (options.publicUrl) {
+        data.public_url = options.publicUrl;
+    }
+    if (options.icon) {
+        data.icon = options.icon;
+    }
+    if (options.note) {
+        data.note = options.note;
+    }
+    if (options.agentNote) {
+        data.agent_note = options.agentNote;
+    }
+    const client = input_1.default.restApiTokenClient();
+    const result = await client.createEnvironment(workspace, data);
+    output_1.default.exitSuccess((0, texts_1.TXT_ENVIRONMENT_CREATED)(result.identifier, result.html_url));
+});
+exports.default = commandEnvironmentCreate;

package/distTs/src/command/environment/delete.js

@@ -0,0 +1,30 @@
+"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 resolve_1 = require("./resolve");
+const commandEnvironmentDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_ENVIRONMENT_DELETE);
+commandEnvironmentDelete.alias('rm');
+commandEnvironmentDelete.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandEnvironmentDelete.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandEnvironmentDelete.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
+commandEnvironmentDelete.argument('<identifier>', texts_1.OPTION_ENVIRONMENT_IDENTIFIER);
+commandEnvironmentDelete.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_ENVIRONMENT_DELETE}`);
+commandEnvironmentDelete.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const environment_id = await (0, resolve_1.resolveEnvironmentId)(client, workspace, identifier, options, 
+    /* strictProject */ true);
+    const confirmed = options.force ||
+        (await output_1.default.confirm((0, texts_1.TXT_ENVIRONMENT_DELETE_CONFIRM)(identifier)));
+    if (!confirmed)
+        output_1.default.exitNormal();
+    await client.deleteEnvironment(workspace, environment_id);
+    output_1.default.exitSuccess((0, texts_1.TXT_ENVIRONMENT_DELETED)(identifier));
+});
+exports.default = commandEnvironmentDelete;

package/distTs/src/command/environment/get.js

@@ -0,0 +1,48 @@
+"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 resolve_1 = require("./resolve");
+const commandEnvironmentGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_ENVIRONMENT_GET);
+commandEnvironmentGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandEnvironmentGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandEnvironmentGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandEnvironmentGet.argument('<identifier>', texts_1.OPTION_ENVIRONMENT_IDENTIFIER);
+commandEnvironmentGet.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_ENVIRONMENT_GET}`);
+commandEnvironmentGet.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const environment_id = await (0, resolve_1.resolveEnvironmentId)(client, workspace, identifier, options);
+    const environment = await client.getEnvironment(workspace, environment_id);
+    if (options.format === 'json') {
+        output_1.default.json(environment);
+    }
+    else {
+        const data = [
+            ['Field', 'Value'],
+            ['ID', environment.id || '-'],
+            ['Identifier', environment.identifier || '-'],
+            ['Name', environment.name || '-'],
+            ['Scope', environment.scope || '-'],
+            ['Tags', (environment.tags || []).join(', ') || '-'],
+            ['Public URL', environment.public_url || '-'],
+            ['Icon', environment.icon || '-'],
+            ['Note', environment.note || '-'],
+            ['Agent note', environment.agent_note || '-'],
+        ];
+        if (environment.project) {
+            data.push(['Project', environment.project.name || '-']);
+        }
+        if (environment.html_url) {
+            data.push(['URL', environment.html_url]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandEnvironmentGet;