bdy 1.25.3-dev → 1.25.4-dev

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/openapi.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiEndpoints = apiEndpoints;
+exports.apiSpecification = apiSpecification;
 const docs_schema_1 = require("@buddy-works/docs-schema");
 const texts_1 = require("./texts");
 const utils_1 = require("./utils");
 const diskCache_1 = require("./diskCache");
 let held = null;
+let specification = null;
 async function apiEndpoints(baseUrl) {
     if (held)
         return held;
@@ -18,10 +20,15 @@ async function apiEndpoints(baseUrl) {
     if (!raw)
         throw new Error(texts_1.ERR_SCHEMA_FETCH_FAILED);
     try {
-        held = docs_schema_1.BuddySchema.from({ api: JSON.parse(raw) }).api;
+        specification = JSON.parse(raw);
+        held = docs_schema_1.BuddySchema.from({ api: specification }).api;
     }
     catch {
         throw new Error(texts_1.ERR_SCHEMA_FETCH_FAILED);
     }
     return held;
 }
+async function apiSpecification(baseUrl) {
+    await apiEndpoints(baseUrl);
+    return specification;
+}

package/distTs/src/output.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const texts_1 = require("./texts");
 const utils_1 = require("./utils");
 const chalk_1 = __importDefault(require("chalk"));
+const node_readline_1 = require("node:readline");
 let _terminal = null;
 function getTerminal() {
     if (!_terminal) {
@@ -134,6 +135,15 @@ class Output {
             msg += '\n';
         getTerminal()(msg);
     }
+    static progress(quiet, output = this.normal.bind(this)) {
+        return (txt, newLine = true, replacePrevious = false) => {
+            if (quiet)
+                return;
+            if (replacePrevious)
+                this.clearPreviousLine();
+            output(txt, newLine);
+        };
+    }
     // Payload output (command results, logs, JSON): bypasses terminal-kit,
     // whose printf-style formatting and ^-markup corrupt data containing
     // % or ^ sequences. newLine=false emits a mid-stream chunk, keeping
@@ -652,6 +662,35 @@ class Output {
     static json(json) {
         this.data(JSON.stringify(json));
     }
+    static async streamCommandLogs(body, jsonl) {
+        // readline preserves UTF-8 and records split across transport chunks.
+        const lines = (0, node_readline_1.createInterface)({ input: body, crlfDelay: Infinity });
+        for await (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof record?.data !== 'string')
+                continue;
+            if (jsonl) {
+                this.json({
+                    type: 'log',
+                    ...(record.stream === 'stdout' || record.stream === 'stderr'
+                        ? { stream: record.stream }
+                        : {}),
+                    data: record.data,
+                });
+            }
+            else if (record.data) {
+                this.data(record.data);
+            }
+        }
+    }
     static exitError(err) {
         this.clearUndici();
         this.clearTerminal();