bdy 1.23.11-dev → 1.23.13-dev-target-commands

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;

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

@@ -0,0 +1,49 @@
+"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 commandTargetList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_TARGET_LIST);
+commandTargetList.alias('ls');
+commandTargetList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetList.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetList.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetList.option('--scope <scope>', texts_1.OPT_COMMAND_TARGET_SCOPE);
+commandTargetList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_LIST}`);
+commandTargetList.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.targetScope(project, options.pipeline, options.environment, options.scope);
+    input_1.default.projectScopeNote(options, project, scope, 'targets');
+    const client = input_1.default.restApiTokenClient();
+    const filters = await (0, scope_1.resolveTargetScope)(client, workspace, project, scope, options);
+    const result = await client.getTargets(workspace, filters);
+    const targets = result.targets || [];
+    if (options.format === 'json') {
+        output_1.default.json(targets);
+    }
+    else {
+        if (targets.length === 0) {
+            output_1.default.exitNormal(texts_1.TXT_TARGET_NOT_FOUND);
+        }
+        const data = [['NAME', 'IDENTIFIER', 'TYPE', 'SCOPE']];
+        for (const target of targets) {
+            data.push([
+                target.name || '-',
+                target.identifier || '-',
+                target.type || '-',
+                (0, scope_1.targetScopeOf)(target),
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetList;

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

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargetScope = exports.targetScopeOf = exports.targetAddressOf = exports.forwardExecLog = exports.resolveTargetId = void 0;
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+// Shared resolve preamble for commands taking a target identifier: line
+// context from flags/env -> /identifiers -> hash id, exiting on a miss.
+const resolveTargetId = async (client, workspace, identifier, options) => {
+    const project = input_1.default.restApiProject(options.project, true);
+    const line = input_1.default.targetLine(project, options.pipeline, options.environment);
+    const { target_id } = await client.getTargetByIdentifier(workspace, identifier, line);
+    if (!target_id) {
+        output_1.default.exitError(texts_1.ERR_TARGET_NOT_FOUND);
+    }
+    return target_id;
+};
+exports.resolveTargetId = resolveTargetId;
+// Lines the CLI requests per log fetch.
+const EXEC_LOG_PAGE = 1000;
+// The exec log endpoint pages by line offset; its `truncated` field
+// describes server-side output truncation, not pagination. `lines` may
+// additionally include a trailing line that is still being written -
+// `next_offset` only advances past committed lines - so exactly
+// next_offset - offset lines are emitted to avoid re-printing the partial
+// line on the next pass. A page shorter than requested means the committed
+// log is drained, so the common case costs a single request.
+const forwardExecLog = async (client, workspace, execId, startOffset, emitPage = (lines) => output_1.default.data(lines.join('\n')), maxLines) => {
+    let offset = startOffset;
+    let emitted = 0;
+    let truncated = false;
+    for (;;) {
+        const pageLimit = maxLines === undefined
+            ? EXEC_LOG_PAGE
+            : Math.min(EXEC_LOG_PAGE, maxLines - emitted);
+        if (pageLimit <= 0)
+            break;
+        const log = await client.getTargetExecLog(workspace, execId, offset, pageLimit);
+        truncated = truncated || !!log.truncated;
+        const next = log.next_offset ?? offset;
+        if (next <= offset)
+            break;
+        const lines = (log.lines || []).slice(0, next - offset);
+        if (lines.length)
+            emitPage(lines);
+        emitted += lines.length;
+        offset = next;
+        if (lines.length < pageLimit)
+            break;
+    }
+    return { offset, truncated };
+};
+exports.forwardExecLog = forwardExecLog;
+// Connection info condensed to one host:port/database cell (auth is left
+// out on purpose - the text view is a summary, credentials stay in json).
+const targetAddressOf = (target) => {
+    if (!target.host)
+        return '-';
+    let address = target.host;
+    if (target.port)
+        address += `:${target.port}`;
+    if (target.database)
+        address += `/${target.database}`;
+    return address;
+};
+exports.targetAddressOf = targetAddressOf;
+const targetScopeOf = (target) => {
+    if (target.pipeline)
+        return utils_1.TARGET_SCOPE.PIPELINE;
+    if (target.environment)
+        return utils_1.TARGET_SCOPE.ENVIRONMENT;
+    if (target.project)
+        return utils_1.TARGET_SCOPE.PROJECT;
+    return utils_1.TARGET_SCOPE.WORKSPACE;
+};
+exports.targetScopeOf = targetScopeOf;
+// Input.targetScope guarantees project is set for the PIPELINE scope.
+// Environments exist on both workspace and project level, so for the
+// ENVIRONMENT scope project is optional and narrows the lookup when given.
+const resolveTargetScope = async (client, workspace, project, scope, options) => {
+    const params = {};
+    if (scope === utils_1.TARGET_SCOPE.PIPELINE) {
+        const { pipeline_id } = await client.getPipelineByIdentifier(workspace, project, options.pipeline);
+        if (!pipeline_id)
+            output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+        params.pipelineId = pipeline_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.ENVIRONMENT) {
+        const query = {
+            environment: options.environment,
+        };
+        if (project)
+            query.project = project;
+        const { environment_id } = await client.getResourceByIdentifier(workspace, query);
+        if (!environment_id)
+            output_1.default.exitError(texts_1.ERR_TARGET_ENVIRONMENT_NOT_FOUND);
+        params.environmentId = environment_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.PROJECT) {
+        params.project = project;
+    }
+    return params;
+};
+exports.resolveTargetScope = resolveTargetScope;

package/distTs/src/command/target/update.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 commandTargetUpdate = (0, utils_1.newCommand)('update', texts_1.DESC_COMMAND_TARGET_UPDATE);
+commandTargetUpdate.alias('edit');
+commandTargetUpdate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetUpdate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetUpdate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetUpdate.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetUpdate.option('--yaml <content|@path>', texts_1.OPTION_TARGET_YAML);
+commandTargetUpdate.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetUpdate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_UPDATE}`);
+commandTargetUpdate.action(async (identifier, options) => {
+    const yaml = input_1.default.restApiYaml(options.yaml);
+    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 body = {
+        yaml: Buffer.from(yaml, 'utf8').toString('base64'),
+    };
+    const result = await client.updateTargetByYaml(workspace, target_id, body);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_UPDATED)(result.identifier, result.html_url));
+});
+exports.default = commandTargetUpdate;

package/distTs/src/command/target.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 });
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+const list_1 = __importDefault(require("./target/list"));
+const get_1 = __importDefault(require("./target/get"));
+const create_1 = __importDefault(require("./target/create"));
+const update_1 = __importDefault(require("./target/update"));
+const delete_1 = __importDefault(require("./target/delete"));
+const exec_1 = __importDefault(require("./target/exec"));
+const commandTarget = (0, utils_1.newCommand)('target', texts_1.DESC_COMMAND_TARGET);
+commandTarget.alias('tg');
+commandTarget.addCommand(list_1.default);
+commandTarget.addCommand(get_1.default);
+commandTarget.addCommand(create_1.default);
+commandTarget.addCommand(update_1.default);
+commandTarget.addCommand(delete_1.default);
+commandTarget.addCommand(exec_1.default);
+exports.default = commandTarget;