bdy 1.23.2-dev → 1.23.4-dev-target-commands

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

@@ -0,0 +1,29 @@
+"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);
+    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;

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

@@ -0,0 +1,44 @@
+"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 distro_1 = require("../../types/distro");
+const commandEnvironmentList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_ENVIRONMENT_LIST);
+commandEnvironmentList.alias('ls');
+commandEnvironmentList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandEnvironmentList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandEnvironmentList.option('--scope <scope>', texts_1.OPT_COMMAND_SCOPE);
+commandEnvironmentList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandEnvironmentList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_ENVIRONMENT_LIST}`);
+commandEnvironmentList.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);
+    const client = input_1.default.restApiTokenClient();
+    const result = await client.getEnvironments(workspace, scope === distro_1.SCOPE.PROJECT ? project : null);
+    const environments = result.environments || [];
+    if (options.format === 'json') {
+        output_1.default.json(environments);
+    }
+    else {
+        if (environments.length === 0) {
+            output_1.default.exitNormal(texts_1.TXT_ENVIRONMENT_NOT_FOUND);
+        }
+        const data = [['NAME', 'IDENTIFIER', 'SCOPE']];
+        for (const environment of environments) {
+            data.push([
+                environment.name || '-',
+                environment.identifier || '-',
+                environment.scope || '-',
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandEnvironmentList;

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

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnvironmentId = void 0;
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+// Shared resolve preamble for commands taking an environment identifier:
+// project context from flags/env -> /identifiers -> hash id, exiting on a
+// miss. Without a project the identifier resolves as a workspace
+// environment; with one, along the project line.
+const resolveEnvironmentId = async (client, workspace, identifier, options) => {
+    const project = input_1.default.restApiProject(options.project, true);
+    const { environment_id } = await client.getEnvironmentByIdentifier(workspace, identifier, project);
+    if (!environment_id) {
+        output_1.default.exitError(texts_1.ERR_ENVIRONMENT_NOT_FOUND);
+    }
+    return environment_id;
+};
+exports.resolveEnvironmentId = resolveEnvironmentId;

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

@@ -0,0 +1,59 @@
+"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 resolve_1 = require("./resolve");
+const commandEnvironmentUpdate = (0, utils_1.newCommand)('update', texts_1.DESC_COMMAND_ENVIRONMENT_UPDATE);
+commandEnvironmentUpdate.alias('edit');
+commandEnvironmentUpdate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandEnvironmentUpdate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandEnvironmentUpdate.option('-n, --name <name>', texts_1.OPTION_ENVIRONMENT_NAME);
+commandEnvironmentUpdate.option('--tags <tags>', texts_1.OPTION_ENVIRONMENT_TAGS);
+commandEnvironmentUpdate.option('--public-url <url>', texts_1.OPTION_ENVIRONMENT_PUBLIC_URL);
+commandEnvironmentUpdate.option('--icon <icon>', texts_1.OPTION_ENVIRONMENT_ICON);
+commandEnvironmentUpdate.option('--note <note>', texts_1.OPT_COMMAND_NOTE);
+commandEnvironmentUpdate.option('--agent-note <note>', texts_1.OPT_COMMAND_AGENT_NOTE);
+commandEnvironmentUpdate.argument('<identifier>', texts_1.OPTION_ENVIRONMENT_IDENTIFIER);
+commandEnvironmentUpdate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_ENVIRONMENT_UPDATE}`);
+commandEnvironmentUpdate.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const body = {};
+    let changed = false;
+    if (options.name) {
+        body.name = options.name;
+        changed = true;
+    }
+    if (options.tags !== undefined) {
+        body.tags = input_1.default.tags(options.tags);
+        changed = true;
+    }
+    if (options.publicUrl !== undefined) {
+        body.public_url = options.publicUrl;
+        changed = true;
+    }
+    if (options.icon) {
+        body.icon = options.icon;
+        changed = true;
+    }
+    if (options.note !== undefined) {
+        body.note = options.note;
+        changed = true;
+    }
+    if (options.agentNote !== undefined) {
+        body.agent_note = options.agentNote;
+        changed = true;
+    }
+    if (!changed) {
+        output_1.default.exitError(texts_1.ERR_COMMAND_NO_UPDATE);
+    }
+    const client = input_1.default.restApiTokenClient();
+    const environment_id = await (0, resolve_1.resolveEnvironmentId)(client, workspace, identifier, options);
+    const result = await client.updateEnvironment(workspace, environment_id, body);
+    output_1.default.exitSuccess((0, texts_1.TXT_ENVIRONMENT_UPDATED)(result.identifier, result.html_url));
+});
+exports.default = commandEnvironmentUpdate;

package/distTs/src/command/environment.js

@@ -0,0 +1,20 @@
+"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 list_1 = __importDefault(require("./environment/list"));
+const get_1 = __importDefault(require("./environment/get"));
+const create_1 = __importDefault(require("./environment/create"));
+const update_1 = __importDefault(require("./environment/update"));
+const delete_1 = __importDefault(require("./environment/delete"));
+const commandEnvironment = (0, utils_1.newCommand)('environment', texts_1.DESC_COMMAND_ENVIRONMENT);
+commandEnvironment.alias('env');
+commandEnvironment.addCommand(list_1.default);
+commandEnvironment.addCommand(get_1.default);
+commandEnvironment.addCommand(create_1.default);
+commandEnvironment.addCommand(update_1.default);
+commandEnvironment.addCommand(delete_1.default);
+exports.default = commandEnvironment;

package/distTs/src/command/pipeline/run/apply.js

@@ -0,0 +1,62 @@
+"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 pipeline_1 = require("../../../types/pipeline");
+const commandPipelineRunApply = (0, utils_1.newCommand)('apply', texts_1.DESC_COMMAND_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRunApply.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRunApply.option('-n, --no-wait', texts_1.OPTION_PIPELINE_RUN_NO_WAIT);
+commandPipelineRunApply.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRunApply.argument('<run-id>', texts_1.OPTION_PIPELINE_RUN_ID);
+commandPipelineRunApply.argument('<run-action-id>', texts_1.OPTION_PIPELINE_RUN_ACTION_ID);
+commandPipelineRunApply.option('-v,--variable <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRunApply.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.action(async (identifier, runId, runActionId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const rid = input_1.default.pipelineRunId(runId);
+    const variables = input_1.default.pipelineRunVariable(options.variable || [], false);
+    const client = input_1.default.restApiTokenClient();
+    const data = await client.getPipelineByIdentifier(workspace, project, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    if (!data.pipeline_id) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+    }
+    const a = await client.getPipelineRunActionExecution(workspace, project, data.pipeline_id, rid, runActionId);
+    let type;
+    if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY) {
+        type = 'APPLY';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION) {
+        type = 'APPROVE_VT';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES) {
+        type = 'APPLY_VARIABLES';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES) {
+        type = 'SET_VARIABLES';
+    }
+    else {
+        output_1.default.exitError(texts_1.ERR_CANT_APPLY_ACTION_EXECUTION);
+    }
+    const body = {
+        operation: type,
+        approve_action_id: runActionId,
+        variables,
+    };
+    await client.pipelineRunApply(workspace, project, data.pipeline_id, rid, body);
+    const OutputPipeline = require('../../../output/pipeline').default;
+    await OutputPipeline.runStatus(client, workspace, project, data.pipeline_id, rid, !options.wait);
+});
+exports.default = commandPipelineRunApply;

package/distTs/src/command/target/create.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 utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const scope_1 = require("./scope");
+const commandTargetCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_TARGET_CREATE);
+commandTargetCreate.alias('add');
+commandTargetCreate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetCreate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetCreate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetCreate.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetCreate.option('--scope <scope>', texts_1.OPT_COMMAND_TARGET_SCOPE);
+commandTargetCreate.option('--yaml <content|@path>', texts_1.OPTION_TARGET_YAML);
+commandTargetCreate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_CREATE}`);
+commandTargetCreate.action(async (options) => {
+    const yaml = input_1.default.restApiYaml(options.yaml);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    const scope = input_1.default.targetScope(project, options.pipeline, options.environment, options.scope);
+    const client = input_1.default.restApiTokenClient();
+    const scopeParams = await (0, scope_1.resolveTargetScope)(client, workspace, project, scope, options);
+    const body = {
+        yaml: Buffer.from(yaml, 'utf8').toString('base64'),
+    };
+    const result = await client.createTargetByYaml(workspace, scopeParams, body);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_CREATED)(result.identifier, result.html_url));
+});
+exports.default = commandTargetCreate;

package/distTs/src/command/target/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 scope_1 = require("./scope");
+const commandTargetDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_TARGET_DELETE);
+commandTargetDelete.alias('rm');
+commandTargetDelete.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetDelete.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetDelete.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetDelete.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetDelete.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
+commandTargetDelete.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetDelete.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_DELETE}`);
+commandTargetDelete.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    const confirmed = options.force || (await output_1.default.confirm((0, texts_1.TXT_TARGET_DELETE_CONFIRM)(identifier)));
+    if (!confirmed)
+        output_1.default.exitNormal();
+    await client.deleteTarget(workspace, target_id);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_DELETED)(identifier));
+});
+exports.default = commandTargetDelete;

package/distTs/src/command/target/exec/command.js

@@ -0,0 +1,65 @@
+"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 scope_1 = require("../scope");
+const EXEC_WAIT_MS = 10000;
+const commandTargetExecCommand = (0, utils_1.newCommand)('command', texts_1.DESC_COMMAND_TARGET_EXEC);
+commandTargetExecCommand.alias('cmd');
+commandTargetExecCommand.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecCommand.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetExecCommand.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetExecCommand.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetExecCommand.option('--wait', texts_1.OPTION_SANDBOX_WAIT);
+commandTargetExecCommand.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetExecCommand.argument('<command>');
+commandTargetExecCommand.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_COMMAND}`);
+commandTargetExecCommand.action(async (identifier, command, options) => {
+    output_1.default.handleSignals();
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    let exec = await client.executeTargetCommand(workspace, target_id, {
+        command,
+    });
+    const execId = exec.execution_id;
+    output_1.default.gray((0, texts_1.TXT_TARGET_EXEC_ID)(execId));
+    if (!options.wait) {
+        output_1.default.exitSuccess((0, texts_1.TXT_TARGET_EXEC_BACKGROUND)(execId));
+    }
+    let offset = 0;
+    const printLog = async () => {
+        for (;;) {
+            const log = await client.getTargetExecLog(workspace, execId, offset);
+            (log.lines || []).forEach((line) => output_1.default.normal(line));
+            const advanced = log.next_offset !== undefined && log.next_offset > offset;
+            if (advanced)
+                offset = log.next_offset;
+            if (!log.truncated || !advanced)
+                break;
+        }
+    };
+    do {
+        if (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS) {
+            exec = await client.getTargetExec(workspace, execId, EXEC_WAIT_MS);
+        }
+        await printLog();
+    } while (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS);
+    if (exec.status === utils_1.TARGET_EXEC_STATUS.SUCCESSFUL) {
+        output_1.default.exitSuccess((0, texts_1.TXT_TARGET_EXEC_SUCCESS)(execId));
+    }
+    else if (exec.status === utils_1.TARGET_EXEC_STATUS.CANCELLED) {
+        output_1.default.exitError((0, texts_1.TXT_TARGET_EXEC_CANCELLED)(execId));
+    }
+    else {
+        if (exec.error_message)
+            output_1.default.gray(exec.error_message);
+        output_1.default.exitError((0, texts_1.TXT_TARGET_EXEC_FAILED)(execId, exec.failure_reason));
+    }
+});
+exports.default = commandTargetExecCommand;

package/distTs/src/command/target/exec/kill.js

@@ -0,0 +1,25 @@
+"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 commandTargetExecKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_TARGET_EXEC_KILL);
+commandTargetExecKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecKill.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
+commandTargetExecKill.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
+commandTargetExecKill.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_KILL}`);
+commandTargetExecKill.action(async (execId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const confirmed = options.force ||
+        (await output_1.default.confirm((0, texts_1.TXT_TARGET_EXEC_KILL_CONFIRM)(execId)));
+    if (!confirmed)
+        output_1.default.exitNormal();
+    await client.cancelTargetExec(workspace, execId);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_EXEC_KILLED)(execId));
+});
+exports.default = commandTargetExecKill;

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

@@ -0,0 +1,54 @@
+"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 scope_1 = require("../scope");
+const commandTargetExecList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_TARGET_EXEC_LIST);
+commandTargetExecList.alias('ls');
+commandTargetExecList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetExecList.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetExecList.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetExecList.option('--limit <n>', texts_1.OPTION_TARGET_EXEC_LIMIT);
+commandTargetExecList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetExecList.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetExecList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_LIST}`);
+commandTargetExecList.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+    const execs = await client.getTargetExecs(workspace, target_id, limit);
+    if (options.format === 'json') {
+        output_1.default.json(execs);
+    }
+    else {
+        if (execs.length === 0) {
+            output_1.default.exitError(texts_1.ERR_TARGET_NO_EXECS);
+        }
+        const data = [
+            ['EXEC ID', 'STATUS', 'COMMAND', 'STARTED', 'FINISHED', 'EXIT CODE'],
+        ];
+        for (const exec of execs) {
+            data.push([
+                exec.execution_id || '-',
+                exec.failure_reason
+                    ? `${exec.status} (${exec.failure_reason})`
+                    : exec.status || '-',
+                (exec.command || '-').substring(0, 40) +
+                    (exec.command?.length > 40 ? '...' : ''),
+                exec.started_at || '-',
+                exec.finished_at || '-',
+                exec.exit_code !== undefined ? String(exec.exit_code) : '-',
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetExecList;

package/distTs/src/command/target/exec/logs.js

@@ -0,0 +1,25 @@
+"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 commandTargetExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_TARGET_EXEC_LOGS);
+commandTargetExecLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecLogs.option('--offset <n>', texts_1.OPTION_TARGET_EXEC_LOG_OFFSET);
+commandTargetExecLogs.option('--limit <n>', texts_1.OPTION_TARGET_EXEC_LOG_LIMIT);
+commandTargetExecLogs.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
+commandTargetExecLogs.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_LOGS}`);
+commandTargetExecLogs.action(async (execId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const offset = options.offset ? parseInt(options.offset, 10) : undefined;
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+    const log = await client.getTargetExecLog(workspace, execId, offset, limit);
+    (log.lines || []).forEach((line) => output_1.default.normal(line));
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetExecLogs;

package/distTs/src/command/target/exec/status.js

@@ -0,0 +1,41 @@
+"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 commandTargetExecStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_TARGET_EXEC_STATUS);
+commandTargetExecStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecStatus.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetExecStatus.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
+commandTargetExecStatus.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_STATUS}`);
+commandTargetExecStatus.action(async (execId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const exec = await client.getTargetExec(workspace, execId);
+    if (options.format === 'json') {
+        output_1.default.json(exec);
+    }
+    else {
+        const data = [
+            ['Property', 'Value'],
+            ['Execution ID', exec.execution_id || '-'],
+            ['Command', exec.command || '-'],
+            ['Status', exec.status || '-'],
+            [
+                'Exit Code',
+                exec.exit_code !== undefined ? String(exec.exit_code) : '-',
+            ],
+            ['Failure Reason', exec.failure_reason || '-'],
+            ['Error', exec.error_message || '-'],
+            ['Started', exec.started_at || '-'],
+            ['Finished', exec.finished_at || '-'],
+        ];
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetExecStatus;

package/distTs/src/command/target/exec.js

@@ -0,0 +1,24 @@
+"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 command_1 = __importDefault(require("./exec/command"));
+const status_1 = __importDefault(require("./exec/status"));
+const kill_1 = __importDefault(require("./exec/kill"));
+const list_1 = __importDefault(require("./exec/list"));
+const logs_1 = __importDefault(require("./exec/logs"));
+const commandTargetExec = (0, utils_1.newCommand)('exec', texts_1.DESC_COMMAND_TARGET_EXEC);
+commandTargetExec.addCommand(command_1.default);
+commandTargetExec.addCommand(status_1.default);
+commandTargetExec.addCommand(kill_1.default);
+commandTargetExec.addCommand(list_1.default);
+commandTargetExec.addCommand(logs_1.default);
+commandTargetExec.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_COMMAND}
+${texts_1.EXAMPLE_TARGET_EXEC_KILL}
+${texts_1.EXAMPLE_TARGET_EXEC_LIST}
+${texts_1.EXAMPLE_TARGET_EXEC_LOGS}
+${texts_1.EXAMPLE_TARGET_EXEC_STATUS}`);
+exports.default = commandTargetExec;