bdy 1.25.3-dev → 1.25.5-dev

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

@@ -7,43 +7,18 @@ const utils_1 = require("../../../utils");
 const texts_1 = require("../../../texts");
 const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
-const commandSandboxExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_EXEC_LOGS, { examples: texts_1.EXAMPLE_SANDBOX_EXEC_LOGS });
+const finishExec_1 = require("../finishExec");
+const commandSandboxExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_EXEC_LOGS, { helpText: texts_1.HELP_SANDBOX_EXEC_JSONL, examples: texts_1.EXAMPLE_SANDBOX_EXEC_LOGS });
 (0, utils_1.sandboxScopeOptions)(commandSandboxExecLogs);
 commandSandboxExecLogs.option('--wait', texts_1.OPTION_SANDBOX_WAIT);
 commandSandboxExecLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxExecLogs.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxExecLogs.option('--format <text|jsonl>', texts_1.OPTION_FORMAT_JSONL);
 commandSandboxExecLogs.action(async (identifier, commandId, options) => {
     output_1.default.handleSignals();
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const client = input_1.default.restApiTokenClient();
     const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
-    const body = await client.streamSandboxCommandLogs(workspace, sandboxId, commandId, !!options.wait);
-    body.on('data', (data) => {
-        if (data) {
-            try {
-                const str = data.toString('utf8').split('\n');
-                str.forEach((s) => {
-                    const json = JSON.parse(s);
-                    if (json.data)
-                        output_1.default.data(json.data);
-                });
-            }
-            catch {
-                // do nothing
-            }
-        }
-    });
-    body.on('close', async () => {
-        const cmdExit = await client.getSandboxCommand(workspace, sandboxId, commandId);
-        if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
-            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(identifier, commandId));
-        }
-        else if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.INPROGRESS) {
-            output_1.default.exitNormal((0, texts_1.TXT_SANDBOX_EXEC_INPROGRESS)(identifier, commandId));
-        }
-        else {
-            output_1.default.exitError((0, texts_1.TXT_SANDBOX_EXEC_FAILED)(identifier, commandId));
-        }
-    });
+    await (0, finishExec_1.finishExec)(client, workspace, sandboxId, identifier, commandId, !!options.wait, options.format === 'jsonl');
 });
 exports.default = commandSandboxExecLogs;

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finishExec = finishExec;
+const output_1 = __importDefault(require("../../output"));
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+async function finishExec(client, workspace, sandboxId, identifier, commandId, follow, jsonl) {
+    const body = await client.streamSandboxCommandLogs(workspace, sandboxId, commandId, follow);
+    await output_1.default.streamCommandLogs(body, jsonl);
+    const cmdExit = await client.getSandboxCommand(workspace, sandboxId, commandId);
+    if (jsonl) {
+        output_1.default.json({
+            type: 'exit',
+            status: cmdExit.status,
+            exit_code: cmdExit.exit_code ?? null,
+        });
+        if ([utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL, utils_1.SANDBOX_EXEC_STATUS.INPROGRESS].includes(cmdExit.status)) {
+            output_1.default.exitNormal();
+        }
+        output_1.default.exitCode(1);
+    }
+    if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(identifier, commandId));
+    }
+    else if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.INPROGRESS) {
+        output_1.default.exitNormal((0, texts_1.TXT_SANDBOX_EXEC_INPROGRESS)(identifier, commandId));
+    }
+    else {
+        output_1.default.exitError((0, texts_1.TXT_SANDBOX_EXEC_FAILED)(identifier, commandId));
+    }
+}

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

@@ -7,15 +7,28 @@ const utils_1 = require("../../utils");
 const texts_1 = require("../../texts");
 const input_1 = __importDefault(require("../../input"));
 const output_1 = __importDefault(require("../../output"));
-const commandSandboxLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_LOGS);
+const commandSandboxLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_LOGS, { examples: texts_1.EXAMPLE_SANDBOX_LOGS });
 commandSandboxLogs.hideVersionUpdate = true;
 (0, utils_1.sandboxScopeOptions)(commandSandboxLogs);
 commandSandboxLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxLogs.option('--format <text|jsonl>', texts_1.OPTION_FORMAT_JSONL);
 commandSandboxLogs.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const client = input_1.default.restApiTokenClient();
     const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
     const { boot_logs } = await client.getSandbox(workspace, sandboxId);
+    if (options.format === 'jsonl') {
+        for (const log of boot_logs || []) {
+            output_1.default.json(typeof log === 'string'
+                ? { type: 'log', data: log }
+                : {
+                    type: 'log',
+                    data: log.data ?? JSON.stringify(log),
+                    ...(log.source ? { source: log.source } : {}),
+                });
+        }
+        output_1.default.exitNormal();
+    }
     output_1.default.exitNormal((boot_logs || []).join('\n'));
 });
 exports.default = commandSandboxLogs;

package/distTs/src/command/sandbox/snapshot/create.js

@@ -13,6 +13,7 @@ commandSandboxSnapshotCreate.alias('add');
 commandSandboxSnapshotCreate.option('-n, --name <name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME);
 commandSandboxSnapshotCreate.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxSnapshotCreate.option('--wait [seconds]', texts_1.OPTION_SANDBOX_WAIT);
+commandSandboxSnapshotCreate.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxSnapshotCreate.action(async (identifier, options) => {
     const humanId = require('human-id').default;
     const workspace = input_1.default.restApiWorkspace(options.workspace);
@@ -26,7 +27,8 @@ commandSandboxSnapshotCreate.action(async (identifier, options) => {
     const snapshot = await client.createSandboxSnapshot(workspace, sandboxId, body);
     const snapshotId = snapshot.id;
     if (options.wait) {
-        output_1.default.normal(texts_1.TXT_SANDBOX_SNAPSHOT_WAITING);
+        if (options.format !== 'json')
+            output_1.default.normal(texts_1.TXT_SANDBOX_SNAPSHOT_WAITING);
         const timeout = parseInt(options.wait, 10) || 300;
         try {
             const status = await client.sandboxWaitForSnapshot(workspace, sandboxId, snapshotId, timeout);
@@ -38,6 +40,12 @@ commandSandboxSnapshotCreate.action(async (identifier, options) => {
             output_1.default.exitError(texts_1.ERR_SANDBOX_SNAPSHOT_TIMEOUT);
         }
     }
+    if (options.format === 'json') {
+        output_1.default.json(options.wait
+            ? await client.getSandboxSnapshot(workspace, sandboxId, snapshotId)
+            : snapshot);
+        output_1.default.exitNormal();
+    }
     output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_SNAPSHOT_CREATED)(snapshotName));
 });
 exports.default = commandSandboxSnapshotCreate;

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

@@ -18,6 +18,7 @@ commandTargetCreate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPE
 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.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandTargetCreate.action(async (options) => {
     const yaml = input_1.default.restApiYaml(options.yaml);
     const workspace = input_1.default.restApiWorkspace(options.workspace);
@@ -29,6 +30,10 @@ commandTargetCreate.action(async (options) => {
         yaml: Buffer.from(yaml, 'utf8').toString('base64'),
     };
     const result = await client.createTargetByYaml(workspace, scopeParams, body);
+    if (options.format === 'json') {
+        output_1.default.json(result);
+        output_1.default.exitNormal();
+    }
     output_1.default.exitSuccess((0, texts_1.TXT_TARGET_CREATED)(result.identifier, result.html_url));
 });
 exports.default = commandTargetCreate;

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

@@ -8,19 +8,32 @@ 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, { examples: texts_1.EXAMPLE_TARGET_EXEC_LOGS });
+const commandTargetExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_TARGET_EXEC_LOGS, { helpText: texts_1.HELP_TARGET_EXEC_LOGS_JSONL, examples: texts_1.EXAMPLE_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.option('--format <text|jsonl>', texts_1.OPTION_FORMAT_JSONL);
 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);
+    const { truncated } = await (0, scope_1.forwardExecLog)(client, workspace, execId, offset, options.format === 'jsonl'
+        ? (lines) => lines.forEach((data) => output_1.default.json({ type: 'log', data }))
+        : undefined, limit);
     if (truncated)
         output_1.default.noteWarning(texts_1.WARN_TARGET_EXEC_TRUNCATED);
+    if (options.format === 'jsonl') {
+        const exec = await client.getTargetExec(workspace, execId);
+        output_1.default.json({
+            type: 'exit',
+            status: exec.status,
+            exit_code: exec.exit_code ?? null,
+            truncated,
+        });
+        output_1.default.exitNormal();
+    }
     output_1.default.exitNormal();
 });
 exports.default = commandTargetExecLogs;

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

@@ -18,6 +18,7 @@ commandTargetUpdate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPE
 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.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandTargetUpdate.action(async (identifier, options) => {
     const yaml = input_1.default.restApiYaml(options.yaml);
     const workspace = input_1.default.restApiWorkspace(options.workspace);
@@ -28,6 +29,10 @@ commandTargetUpdate.action(async (identifier, options) => {
         yaml: Buffer.from(yaml, 'utf8').toString('base64'),
     };
     const result = await client.updateTargetByYaml(workspace, target_id, body);
+    if (options.format === 'json') {
+        output_1.default.json(result);
+        output_1.default.exitNormal();
+    }
     output_1.default.exitSuccess((0, texts_1.TXT_TARGET_UPDATED)(result.identifier, result.html_url));
 });
 exports.default = commandTargetUpdate;

package/distTs/src/command/yaml/validate.js

@@ -22,9 +22,17 @@ function prettifyKey(key) {
         .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
         .join(' ');
 }
-function outputErrors(result, indent) {
+function recordError(context, path, message) {
+    context.errors.push({
+        pipeline: context.pipeline,
+        path: path.replace(/\.(\d+)(?=\.|$)/g, '[$1]'),
+        message,
+    });
+}
+function outputErrors(result, indent, context, prefix = '') {
     for (const err of result.errors) {
-        output_1.default.muted(`${indent}${err.path}: ${err.message}`);
+        recordError(context, [prefix, err.path].filter(Boolean).join('.'), err.message);
+        context.output.muted(`${indent}${err.path}: ${err.message}`);
     }
 }
 function valueType(value) {
@@ -34,9 +42,10 @@ function valueType(value) {
         return 'array';
     return typeof value;
 }
-function reportWrongContainer(header, expected, value) {
-    output_1.default.error(header);
-    output_1.default.muted(`  ${(0, texts_1.ERR_YAML_MUST_BE)(expected, valueType(value))}`);
+function reportWrongContainer(header, expected, value, context, path) {
+    recordError(context, path, (0, texts_1.ERR_YAML_MUST_BE)(expected, valueType(value)));
+    context.output.error(header);
+    context.output.muted(`  ${(0, texts_1.ERR_YAML_MUST_BE)(expected, valueType(value))}`);
     return 1;
 }
 // Array whose items reference a def — directly, or via a single $ref branch in
@@ -117,85 +126,101 @@ function itemLabel(value, index, discProp) {
         name = `#${index + 1}`;
     return discProp && value && value[discProp] ? `${name} (${value[discProp]})` : name;
 }
-function validateScalarItem(item, section) {
+function validateScalarItem(item, section, context, path) {
     // Null errors even where the section takes a string: coerceTypes cannot fix a root scalar.
     if (item === null || !section.scalar) {
-        output_1.default.error(`  ${String(item)}: ${(0, texts_1.ERR_YAML_MUST_BE)('object', valueType(item))}`);
+        recordError(context, path, (0, texts_1.ERR_YAML_MUST_BE)('object', valueType(item)));
+        context.output.error(`  ${String(item)}: ${(0, texts_1.ERR_YAML_MUST_BE)('object', valueType(item))}`);
         return 1;
     }
     const result = (0, schemaUtils_1.validateAgainstSchema)({ ...section.scalar, $defs: (0, schemaUtils_1.loadRawSchema)().$defs }, item);
     if (result.valid) {
-        output_1.default.green(`  ${String(item)}`);
+        context.output.green(`  ${String(item)}`);
         return 0;
     }
-    output_1.default.error(`  ${String(item)}`);
-    outputErrors(result, '    ');
+    context.output.error(`  ${String(item)}`);
+    outputErrors(result, '    ', context, path);
     return result.errors.length;
 }
-function validateItemSection(unions, items, section) {
+function validateItemSection(unions, items, section, context) {
     const refName = section.defName;
     const discProp = unions.get(refName)?.property ?? null;
     let errors = 0;
     for (let i = 0; i < items.length; i++) {
         const item = items[i];
+        const path = `${section.key}[${i}]`;
         if (item === null || typeof item !== 'object' || Array.isArray(item)) {
-            errors += validateScalarItem(item, section);
+            errors += validateScalarItem(item, section, context, path);
             continue;
         }
         const label = itemLabel(item, i, discProp);
         const resolved = resolveDef(unions, refName, item);
         if ('missingType' in resolved) {
-            output_1.default.error(`  ${label}: ${(0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType)}`);
+            recordError(context, `${path}.${resolved.missingType}`, (0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType));
+            context.output.error(`  ${label}: ${(0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType)}`);
             errors++;
             continue;
         }
         if ('unknownType' in resolved) {
-            output_1.default.error(`  ${label}: ${(0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType)}`);
+            recordError(context, `${path}.${resolved.prop}`, (0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType));
+            context.output.error(`  ${label}: ${(0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType)}`);
             errors++;
             continue;
         }
         const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, item);
         if (result.valid) {
-            output_1.default.green(`  ${label}`);
+            context.output.green(`  ${label}`);
         }
         else {
             errors += result.errors.length;
-            output_1.default.error(`  ${label}`);
-            outputErrors(result, '    ');
+            context.output.error(`  ${label}`);
+            outputErrors(result, '    ', context, path);
         }
     }
     return errors;
 }
-function validateObjectSection(unions, label, value, refName) {
+function validateObjectSection(unions, label, value, refName, context, path) {
     const resolved = resolveDef(unions, refName, value);
     if ('missingType' in resolved) {
-        output_1.default.error(label);
-        output_1.default.muted(`  ${(0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType)}`);
+        context.output.error(label);
+        recordError(context, `${path}.${resolved.missingType}`, (0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType));
+        context.output.muted(`  ${(0, texts_1.ERR_YAML_ITEM_MISSING)(resolved.missingType)}`);
         return 1;
     }
     if ('unknownType' in resolved) {
-        output_1.default.error(label);
-        output_1.default.muted(`  ${(0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType)}`);
+        context.output.error(label);
+        recordError(context, `${path}.${resolved.prop}`, (0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType));
+        context.output.muted(`  ${(0, texts_1.ERR_YAML_ITEM_UNKNOWN)(resolved.prop, resolved.unknownType)}`);
         return 1;
     }
     const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, value);
     if (result.valid) {
-        output_1.default.green(label);
+        context.output.green(label);
         return 0;
     }
-    output_1.default.error(label);
-    outputErrors(result, '  ');
+    context.output.error(label);
+    outputErrors(result, '  ', context, path);
     return result.errors.length;
 }
-function validateSinglePipeline(parsed, label, unions) {
+function validateSinglePipeline(parsed, label, unions, context) {
     let errors = 0;
     const defs = (0, schemaUtils_1.getAllDefs)();
     const pipelineDef = defs['PipelineYaml'];
     const props = pipelineDef?.properties || {};
-    const allKnownKeys = new Set([...Object.keys(props), ...SCHEMA_OMITTED_TOP_LEVEL_KEYS]);
+    const allKnownKeys = new Set([
+        ...Object.keys(props),
+        ...SCHEMA_OMITTED_TOP_LEVEL_KEYS,
+    ]);
     const unknownKeys = Object.keys(parsed).filter((k) => !allKnownKeys.has(k));
     if (unknownKeys.length > 0) {
-        output_1.default.yellow(`${label}${(0, texts_1.TXT_YAML_UNKNOWN_TOP_LEVEL_KEYS)(unknownKeys.join(', '))}`);
+        for (const key of unknownKeys) {
+            context.warnings.push({
+                pipeline: context.pipeline,
+                path: key,
+                message: (0, texts_1.TXT_YAML_UNKNOWN_TOP_LEVEL_KEYS)(key),
+            });
+        }
+        context.output.yellow(`${label}${(0, texts_1.TXT_YAML_UNKNOWN_TOP_LEVEL_KEYS)(unknownKeys.join(', '))}`);
     }
     const { itemSections, objectSections, settingsProps } = classifySections(props);
     if (Object.keys(settingsProps).length > 0) {
@@ -212,12 +237,12 @@ function validateSinglePipeline(parsed, label, unions) {
             $defs: rawSchema.$defs,
         }, settingsData);
         if (result.valid) {
-            output_1.default.green(`${label}Pipeline settings`);
+            context.output.green(`${label}Pipeline settings`);
         }
         else {
             errors += result.errors.length;
-            output_1.default.error(`${label}Pipeline settings`);
-            outputErrors(result, '  ');
+            context.output.error(`${label}Pipeline settings`);
+            outputErrors(result, '  ', context);
         }
     }
     const itemByKey = new Map(itemSections.map((s) => [s.key, s]));
@@ -232,27 +257,52 @@ function validateSinglePipeline(parsed, label, unions) {
         const header = `${label}${prettifyKey(key)}`;
         if (itemByKey.has(key)) {
             if (!Array.isArray(value)) {
-                errors += reportWrongContainer(header, 'array', value);
+                errors += reportWrongContainer(header, 'array', value, context, key);
                 continue;
             }
-            output_1.default.blue(header);
-            errors += validateItemSection(unions, value, itemByKey.get(key));
+            context.output.blue(header);
+            errors += validateItemSection(unions, value, itemByKey.get(key), context);
         }
         else if (objByKey.has(key)) {
             if (typeof value !== 'object' || Array.isArray(value)) {
-                errors += reportWrongContainer(header, 'object', value);
+                errors += reportWrongContainer(header, 'object', value, context, key);
                 continue;
             }
-            errors += validateObjectSection(unions, header, value, objByKey.get(key));
+            errors += validateObjectSection(unions, header, value, objByKey.get(key), context, key);
         }
     }
     return errors;
 }
-function validatePipelineFile(file, unions) {
+function validatePipelineFile(file, unions, json) {
+    const context = {
+        output: {
+            normal: output_1.default.progress(json),
+            error: output_1.default.progress(json, output_1.default.error.bind(output_1.default)),
+            muted: output_1.default.progress(json, output_1.default.muted.bind(output_1.default)),
+            green: output_1.default.progress(json, output_1.default.green.bind(output_1.default)),
+            yellow: output_1.default.progress(json, output_1.default.yellow.bind(output_1.default)),
+            blue: output_1.default.progress(json, output_1.default.blue.bind(output_1.default)),
+        },
+        pipeline: 0,
+        errors: [],
+        warnings: [],
+    };
+    const invalidDocument = (message) => {
+        if (json) {
+            recordError(context, '', message);
+            output_1.default.json({
+                valid: false,
+                pipelines: 0,
+                errors: context.errors,
+                warnings: context.warnings,
+            });
+            output_1.default.exitCode(1);
+        }
+        output_1.default.exitError(message);
+    };
     const filePath = (0, path_1.resolve)(file);
     if (!(0, fs_1.existsSync)(filePath)) {
-        output_1.default.exitError((0, texts_1.ERR_YAML_VALIDATE_FILE_NOT_FOUND)(file));
-        return;
+        invalidDocument((0, texts_1.ERR_YAML_VALIDATE_FILE_NOT_FOUND)(file));
     }
     const YAML = require('yaml');
     const content = (0, fs_1.readFileSync)(filePath, 'utf8');
@@ -261,33 +311,40 @@ function validatePipelineFile(file, unions) {
         parsed = YAML.parse(content);
     }
     catch (e) {
-        output_1.default.exitError((0, texts_1.ERR_YAML_PARSE)(e.message));
-        return;
+        invalidDocument((0, texts_1.ERR_YAML_PARSE)(e.message));
     }
     if (!parsed || typeof parsed !== 'object') {
-        output_1.default.exitError(texts_1.ERR_YAML_NOT_ARRAY);
-        return;
+        invalidDocument(texts_1.ERR_YAML_NOT_ARRAY);
     }
     if (!Array.isArray(parsed)) {
-        output_1.default.exitError(texts_1.ERR_YAML_PLAIN_OBJECT);
-        return;
+        invalidDocument(texts_1.ERR_YAML_PLAIN_OBJECT);
     }
     if (parsed.length === 0) {
-        output_1.default.exitError(texts_1.ERR_YAML_EMPTY_ARRAY);
-        return;
+        invalidDocument(texts_1.ERR_YAML_EMPTY_ARRAY);
     }
     let errors = 0;
     for (let i = 0; i < parsed.length; i++) {
         const pipeline = parsed[i];
+        context.pipeline = i + 1;
         if (!pipeline || typeof pipeline !== 'object' || Array.isArray(pipeline)) {
-            output_1.default.error(`  ${(0, texts_1.ERR_YAML_PIPELINE_NOT_OBJECT)(i + 1)}`);
+            recordError(context, '', (0, texts_1.ERR_YAML_PIPELINE_NOT_OBJECT)(i + 1));
+            context.output.error(`  ${(0, texts_1.ERR_YAML_PIPELINE_NOT_OBJECT)(i + 1)}`);
             errors++;
             continue;
         }
         const pipelineLabel = parsed.length > 1 ? `[${pipeline.pipeline || i + 1}] ` : '';
-        errors += validateSinglePipeline(pipeline, pipelineLabel, unions);
+        errors += validateSinglePipeline(pipeline, pipelineLabel, unions, context);
+    }
+    if (json) {
+        output_1.default.json({
+            valid: errors === 0,
+            pipelines: parsed.length,
+            errors: context.errors,
+            warnings: context.warnings,
+        });
+        output_1.default.exitCode(errors > 0 ? 1 : 0);
     }
-    output_1.default.normal('');
+    context.output.normal('');
     if (errors > 0) {
         output_1.default.exitError((0, texts_1.ERR_YAML_VALIDATE_FAILED_COUNT)(errors));
     }
@@ -296,11 +353,13 @@ function validatePipelineFile(file, unions) {
     }
 }
 const commandYamlValidate = (0, utils_1.newCommand)('validate', texts_1.DESC_COMMAND_YAML_VALIDATE, {
+    helpText: texts_1.HELP_YAML_VALIDATE_JSON,
     examples: texts_1.EXAMPLE_YAML_VALIDATE,
 });
 commandYamlValidate.argument('<file>', texts_1.OPTION_YAML_VALIDATE_FILE);
-commandYamlValidate.action(async (file) => {
+commandYamlValidate.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandYamlValidate.action(async (file, options) => {
     await (0, schemaUtils_1.ensureYamlSchema)();
-    validatePipelineFile(file, await unionMappings((0, schemaUtils_1.getAllDefs)()));
+    validatePipelineFile(file, await unionMappings((0, schemaUtils_1.getAllDefs)()), options.format === 'json');
 });
 exports.default = commandYamlValidate;

package/distTs/src/index.js

@@ -43,4 +43,9 @@ const isAgentRun = process.argv[2] === 'agent' && process.argv[3] === 'run';
 const program = isAgentRun
     ? require('./agentIndex').default()
     : require('./cliIndex').default();
-program.parse();
+program.parseAsync().catch((err) => {
+    if (isEpipe(err))
+        process.exit(0);
+    logger_1.default.fatal(err);
+    output_1.default.exitError(err);
+});

package/distTs/src/input.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const cliError_1 = __importDefault(require("./cliError"));
 const output_1 = __importDefault(require("./output"));
 const netmask_1 = require("netmask");
 const punycode_1 = __importDefault(require("punycode/"));
@@ -360,7 +361,7 @@ class Input {
         if (!t && inSandbox && tokenEnv)
             t = tokenEnv;
         if (!t && !allowNoToken) {
-            output_1.default.exitError(texts_1.ERR_REST_API_TOKEN);
+            output_1.default.exitError(new cliError_1.default('unauthorized', texts_1.ERR_REST_API_NOT_LOGGED_IN, texts_1.TXT_CLI_LOGIN_HINT));
         }
         return {
             token: t || '',
@@ -488,7 +489,7 @@ class Input {
     static runVariablesFromFile(p, encrypted) {
         const s = (0, node_path_1.resolve)(p);
         if (!node_fs_1.default.existsSync(s)) {
-            output_1.default.exitError(texts_1.ERR_RUN_VAR_FILE_NOT_FOUND);
+            output_1.default.exitError(new cliError_1.default('file_not_found', texts_1.ERR_RUN_VAR_FILE_NOT_FOUND));
         }
         let parsed;
         try {
@@ -524,7 +525,7 @@ class Input {
             }
             catch (err) {
                 if (err.code === 'ENOENT')
-                    output_1.default.exitError(texts_1.ERR_RUN_VAR_FILE_NOT_FOUND);
+                    output_1.default.exitError(new cliError_1.default('file_not_found', texts_1.ERR_RUN_VAR_FILE_NOT_FOUND));
                 output_1.default.exitError(texts_1.ERR_RUN_VAR_FILE_INVALID);
             }
             list.push({
@@ -835,7 +836,7 @@ class Input {
             return r;
         }
         else {
-            output_1.default.exitError(texts_1.ERR_REST_API_REGION);
+            output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_REST_API_REGION));
         }
     }
     static restApiBaseUrlFromToken(token) {
@@ -894,14 +895,14 @@ class Input {
             return new URL(`https://${u}`);
         }
         catch {
-            output_1.default.exitError(texts_1.ERR_REST_API_URL);
+            output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_REST_API_URL));
         }
     }
     static resolvePath(path) {
         const p = (0, node_path_1.resolve)(path);
         const exists = node_fs_1.default.existsSync(p);
         if (!exists) {
-            output_1.default.exitError(texts_1.ERR_PATH_NOT_EXISTS);
+            output_1.default.exitError(new cliError_1.default('file_not_found', texts_1.ERR_PATH_NOT_EXISTS));
         }
         return p;
     }
@@ -923,7 +924,7 @@ class Input {
         if (!w) {
             if (allowNull)
                 return null;
-            output_1.default.exitError(texts_1.ERR_REST_API_WORKSPACE);
+            output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_REST_API_WORKSPACE, texts_1.TXT_CLI_WORKSPACE_HINT));
         }
         return w;
     }
@@ -1255,14 +1256,14 @@ class Input {
         if (!p) {
             if (allowNull)
                 return null;
-            output_1.default.exitError(texts_1.ERR_REST_API_PROJECT);
+            output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_REST_API_PROJECT, texts_1.TXT_CLI_PROJECT_HINT));
         }
         return p;
     }
     static sandboxBootScript(s) {
         const p = (0, node_path_1.resolve)(s);
         if (!node_fs_1.default.existsSync(p))
-            output_1.default.exitError(texts_1.ERR_SANDBOX_BOOT_SCRIPT_NOT_EXISTS);
+            output_1.default.exitError(new cliError_1.default('file_not_found', texts_1.ERR_SANDBOX_BOOT_SCRIPT_NOT_EXISTS));
         return node_fs_1.default.readFileSync(p, 'utf8');
     }
     static tags(tags) {
@@ -1273,11 +1274,11 @@ class Input {
     }
     static restApiYaml(yaml) {
         if (!yaml)
-            output_1.default.exitError(texts_1.ERR_REST_API_YAML);
+            output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_REST_API_YAML));
         if (yaml.startsWith('@')) {
             const p = (0, node_path_1.resolve)(yaml.replace(/^@/, ''));
             if (!node_fs_1.default.existsSync(p))
-                output_1.default.exitError(texts_1.ERR_REST_API_YAML_NOT_FOUND);
+                output_1.default.exitError(new cliError_1.default('file_not_found', texts_1.ERR_REST_API_YAML_NOT_FOUND));
             return node_fs_1.default.readFileSync(p, 'utf8');
         }
         return yaml;