bdy 1.23.13 → 1.23.14-dev

package/distTs/src/command/environment/list.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 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);
+    input_1.default.projectScopeNote(options, project, scope, 'environments');
+    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,39 @@
+"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.
+//
+// strictProject is for mutating commands (update/delete): an explicit -p is
+// a statement "the environment of this project", so the resolved environment
+// must actually live there. Without it /identifiers silently falls back to
+// the workspace environment of the same identifier and the write lands on a
+// workspace-wide resource. Reads keep the fallback - that is how workspace
+// environments stay addressable from inside a project context.
+const resolveEnvironmentId = async (client, workspace, identifier, options, strictProject = false) => {
+    const project = input_1.default.restApiProject(options.project, true);
+    const resolved = await client.getEnvironmentByIdentifier(workspace, identifier, project);
+    // A nonexistent project is rejected by the API client
+    // (getResourceByIdentifier); here only the environment itself can miss.
+    if (!resolved.environment_id) {
+        output_1.default.exitError(texts_1.ERR_ENVIRONMENT_NOT_FOUND);
+    }
+    if (strictProject && options.project) {
+        const environment = await client.getEnvironment(workspace, resolved.environment_id);
+        // a workspace environment carries no project, so this also fails the
+        // workspace-fallback case
+        if (environment.project?.name !== resolved.project_identifier) {
+            output_1.default.exitError(texts_1.ERR_ENVIRONMENT_NOT_FOUND);
+        }
+    }
+    return resolved.environment_id;
+};
+exports.resolveEnvironmentId = resolveEnvironmentId;

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

@@ -0,0 +1,60 @@
+"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, 
+    /* strictProject */ true);
+    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/project/git/credential.js

@@ -60,10 +60,12 @@ commandProjectGitCredential.action(async (action) => {
                     projects.projects[0].html_url.includes(input.host);
         }
         if (myHost) {
-            output_1.default.normal(`protocol=${input.protocol || 'https'}`);
-            output_1.default.normal(`host=${input.host}`);
-            output_1.default.normal(`username=${client.token}`);
-            output_1.default.normal(`password=`);
+            // git credential protocol output - a machine-read payload, so it
+            // bypasses terminal-kit formatting
+            output_1.default.data(`protocol=${input.protocol || 'https'}`);
+            output_1.default.data(`host=${input.host}`);
+            output_1.default.data(`username=${client.token}`);
+            output_1.default.data(`password=`);
         }
     }
     catch {

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

@@ -43,7 +43,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
                     str.forEach((s) => {
                         const json = JSON.parse(s);
                         if (json.data)
-                            output_1.default.normal(json.data);
+                            output_1.default.data(json.data);
                     });
                 }
                 catch {

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

@@ -31,7 +31,7 @@ commandSandboxExecLogs.action(async (identifier, commandId, options) => {
                 str.forEach((s) => {
                     const json = JSON.parse(s);
                     if (json.data)
-                        output_1.default.normal(json.data);
+                        output_1.default.data(json.data);
                 });
             }
             catch {

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,31 @@
+"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, 
+    /* strictLine */ true);
+    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,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+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('--async', texts_1.OPTION_TARGET_EXEC_ASYNC);
+commandTargetExecCommand.option('--file <path>', texts_1.OPTION_TARGET_EXEC_FILE);
+commandTargetExecCommand.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetExecCommand.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetExecCommand.argument('[command]', texts_1.OPTION_TARGET_EXEC_COMMAND);
+commandTargetExecCommand.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_EXEC_COMMAND}`);
+commandTargetExecCommand.action(async (identifier, command, options) => {
+    output_1.default.handleSignals();
+    if (options.file && command !== undefined) {
+        output_1.default.exitError(texts_1.ERR_TARGET_EXEC_COMMAND_CONFLICT);
+    }
+    let cmd = command;
+    if (options.file) {
+        try {
+            cmd = node_fs_1.default.readFileSync(options.file, 'utf8');
+        }
+        catch {
+            output_1.default.exitError((0, texts_1.ERR_TARGET_EXEC_FILE_NOT_FOUND)(options.file));
+        }
+    }
+    if (!cmd?.trim()) {
+        output_1.default.exitError(texts_1.ERR_TARGET_EXEC_NO_COMMAND);
+    }
+    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, 
+    /* strictLine */ true);
+    let exec = await client.executeTargetCommand(workspace, target_id, {
+        command: cmd,
+    });
+    const execId = exec.execution_id;
+    const json = options.format === 'json';
+    if (options.async) {
+        if (json) {
+            output_1.default.json(exec);
+        }
+        else {
+            output_1.default.note((0, texts_1.TXT_TARGET_EXEC_BACKGROUND)(execId));
+            output_1.default.data(execId);
+        }
+        output_1.default.exitNormal();
+    }
+    if (json) {
+        while (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS) {
+            exec = await client.getTargetExec(workspace, execId, EXEC_WAIT_MS);
+        }
+        const log = [];
+        await (0, scope_1.forwardExecLog)(client, workspace, execId, 0, (lines) => log.push(...lines));
+        output_1.default.json({ ...exec, log });
+        output_1.default.exitCode(exec.status === utils_1.TARGET_EXEC_STATUS.SUCCESSFUL ? 0 : 1);
+    }
+    output_1.default.note((0, texts_1.TXT_TARGET_EXEC_ID)(execId));
+    let offset = 0;
+    let truncated = false;
+    // bytes_out from the status long-poll tells whether there is anything
+    // new to fetch, saving a log request per quiet poll cycle.
+    let loggedBytes;
+    const drainLog = async () => {
+        loggedBytes = exec.bytes_out;
+        const log = await (0, scope_1.forwardExecLog)(client, workspace, execId, offset);
+        offset = log.offset;
+        truncated = truncated || log.truncated;
+    };
+    while (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS) {
+        exec = await client.getTargetExec(workspace, execId, EXEC_WAIT_MS);
+        if (exec.bytes_out !== loggedBytes)
+            await drainLog();
+    }
+    if (loggedBytes === undefined || exec.bytes_out !== loggedBytes) {
+        await drainLog();
+    }
+    if (exec.truncated || truncated) {
+        output_1.default.noteWarning(texts_1.WARN_TARGET_EXEC_TRUNCATED);
+    }
+    if (exec.status === utils_1.TARGET_EXEC_STATUS.SUCCESSFUL) {
+        output_1.default.note((0, texts_1.TXT_TARGET_EXEC_SUCCESS)(execId));
+        output_1.default.exitNormal();
+    }
+    output_1.default.exitError(exec.status === utils_1.TARGET_EXEC_STATUS.CANCELLED
+        ? (0, texts_1.TXT_TARGET_EXEC_CANCELLED)(execId)
+        : (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,31 @@
+"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();
+    // Resolve the exec before the prompt so a bad id fails the same way
+    // (Resource not found, exit 1) with and without --force - otherwise the
+    // auto-declined prompt exits 0 without ever checking the id. With --force
+    // the DELETE itself surfaces the 404, so the extra request is skipped.
+    if (!options.force)
+        await client.getTargetExec(workspace, execId);
+    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,53 @@
+"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 || '-',
+                (0, utils_1.truncate)(exec.command || '-', 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,27 @@
+"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 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) : 0;
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+    const { truncated } = await (0, scope_1.forwardExecLog)(client, workspace, execId, offset, undefined, limit);
+    if (truncated)
+        output_1.default.noteWarning(texts_1.WARN_TARGET_EXEC_TRUNCATED);
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetExecLogs;

package/distTs/src/command/target/exec/status.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 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 {
+        // The table renderer pads every Value cell to the widest one, so a long
+        // SQL command would blow the whole table up; the full text is available
+        // via --format json.
+        const data = [
+            ['Property', 'Value'],
+            ['Execution ID', exec.execution_id || '-'],
+            ['Command', (0, utils_1.truncate)(exec.command || '-', 100)],
+            ['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;

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

@@ -0,0 +1,63 @@
+"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 commandTargetGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_TARGET_GET);
+commandTargetGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetGet.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetGet.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetGet.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetGet.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_GET}`);
+commandTargetGet.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 target = await client.getTarget(workspace, target_id);
+    if (options.format === 'json') {
+        output_1.default.json(target);
+    }
+    else {
+        const data = [
+            ['Field', 'Value'],
+            ['ID', target.id || '-'],
+            ['Identifier', target.identifier || '-'],
+            ['Name', target.name || '-'],
+            ['Type', target.type || '-'],
+            ['Scope', (0, scope_1.targetScopeOf)(target)],
+            ['Address', (0, scope_1.targetAddressOf)(target)],
+            ['Tags', (target.tags || []).join(', ') || '-'],
+            ['Note', target.note || '-'],
+            ['Agent note', target.agent_note || '-'],
+            ['Disabled', target.disabled ? 'true' : 'false'],
+        ];
+        if (target.project) {
+            data.push(['Project', target.project.name || '-']);
+        }
+        if (target.pipeline) {
+            data.push([
+                'Pipeline',
+                target.pipeline.identifier || String(target.pipeline.id) || '-',
+            ]);
+        }
+        if (target.environment) {
+            data.push([
+                'Environment',
+                target.environment.identifier || target.environment.id || '-',
+            ]);
+        }
+        if (target.html_url) {
+            data.push(['URL', target.html_url]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetGet;