bdy 1.23.3-dev → 1.23.4-dev-target-commands

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

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_1 = require("../../utils");
+const output_1 = __importDefault(require("../../output"));
+const texts_1 = require("../../texts");
+const schemaUtils_1 = require("./schemaUtils");
+// Valid top-level keys the schema's PipelineYaml.properties omits (everything
+// else is derived from the schema, so this only covers genuine gaps).
+const SCHEMA_OMITTED_TOP_LEVEL_KEYS = ['git_config_ref'];
+const LABEL_KEYS = ['action', 'target', 'name', 'key', 'title', 'trigger_condition'];
+function stripRef(ref) {
+    return ref.replace('#/$defs/', '');
+}
+function prettifyKey(key) {
+    return key
+        .split('_')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+function outputErrors(result, indent) {
+    for (const err of result.errors) {
+        output_1.default.muted(`${indent}${err.path}: ${err.message}`);
+    }
+}
+// Array whose items reference a def — directly, or via a single $ref branch in
+// items.oneOf (how `targets` mixes a string ref with an object form).
+function itemRef(prop) {
+    if (!prop || prop.type !== 'array' || !prop.items)
+        return null;
+    if (prop.items.$ref)
+        return stripRef(prop.items.$ref);
+    if (Array.isArray(prop.items.oneOf)) {
+        const refs = prop.items.oneOf.filter((b) => b && b.$ref);
+        if (refs.length === 1)
+            return stripRef(refs[0].$ref);
+    }
+    return null;
+}
+function classifySections(props) {
+    const itemSections = [];
+    const objectSections = [];
+    const settingsProps = {};
+    for (const [key, prop] of Object.entries(props)) {
+        const ref = itemRef(prop);
+        if (ref) {
+            itemSections.push({ key, defName: ref });
+        }
+        else if (prop && prop.$ref) {
+            objectSections.push({ key, defName: stripRef(prop.$ref) });
+        }
+        else {
+            settingsProps[key] = prop;
+        }
+    }
+    return { itemSections, objectSections, settingsProps };
+}
+function discriminatorProp(def) {
+    return def && def.oneOf && def.discriminator ? def.discriminator.propertyName : null;
+}
+// Resolve a discriminated def to its concrete branch by the item's `type`, so
+// AJV always validates against a single def (never a oneOf). Plain defs pass through.
+function resolveDef(defs, refName, value) {
+    const def = defs[refName];
+    const prop = discriminatorProp(def);
+    if (!prop)
+        return { defName: refName };
+    const dv = value?.[prop];
+    if (dv === undefined || dv === null)
+        return { missingType: prop };
+    for (const branch of def.oneOf) {
+        const branchName = branch && branch.$ref ? stripRef(branch.$ref) : null;
+        if (!branchName)
+            continue;
+        if (defs[branchName]?.properties?.[prop]?.const === dv)
+            return { defName: branchName };
+    }
+    return { unknownType: String(dv), prop };
+}
+function itemLabel(value, index, discProp) {
+    let name;
+    for (const k of LABEL_KEYS) {
+        if (value && value[k]) {
+            name = String(value[k]);
+            break;
+        }
+    }
+    if (!name && !discProp && value && value.type)
+        name = String(value.type);
+    if (!name)
+        name = `#${index + 1}`;
+    return discProp && value && value[discProp] ? `${name} (${value[discProp]})` : name;
+}
+function validateItemSection(defs, items, refName) {
+    const discProp = discriminatorProp(defs[refName]);
+    let errors = 0;
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+            output_1.default.green(`  ${String(item)}`);
+            continue;
+        }
+        const label = itemLabel(item, i, discProp);
+        const resolved = resolveDef(defs, refName, item);
+        if ('missingType' in resolved) {
+            output_1.default.error(`  ${label}: missing "${resolved.missingType}"`);
+            errors++;
+            continue;
+        }
+        if ('unknownType' in resolved) {
+            output_1.default.error(`  ${label}: unknown ${resolved.prop} "${resolved.unknownType}"`);
+            errors++;
+            continue;
+        }
+        const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, item);
+        if (result.valid) {
+            output_1.default.green(`  ${label}`);
+        }
+        else {
+            errors += result.errors.length;
+            output_1.default.error(`  ${label}`);
+            outputErrors(result, '    ');
+        }
+    }
+    return errors;
+}
+function validateObjectSection(defs, label, value, refName) {
+    const resolved = resolveDef(defs, refName, value);
+    if ('missingType' in resolved) {
+        output_1.default.error(label);
+        output_1.default.muted(`  missing "${resolved.missingType}"`);
+        return 1;
+    }
+    if ('unknownType' in resolved) {
+        output_1.default.error(label);
+        output_1.default.muted(`  unknown ${resolved.prop} "${resolved.unknownType}"`);
+        return 1;
+    }
+    const result = (0, schemaUtils_1.validateAgainstDef)(resolved.defName, value);
+    if (result.valid) {
+        output_1.default.green(label);
+        return 0;
+    }
+    output_1.default.error(label);
+    outputErrors(result, '  ');
+    return result.errors.length;
+}
+function validateSinglePipeline(parsed, label) {
+    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 unknownKeys = Object.keys(parsed).filter((k) => !allKnownKeys.has(k));
+    if (unknownKeys.length > 0) {
+        output_1.default.yellow(`${label}Unknown top-level keys: ${unknownKeys.join(', ')}`);
+    }
+    const { itemSections, objectSections, settingsProps } = classifySections(props);
+    if (Object.keys(settingsProps).length > 0) {
+        const settingsData = {};
+        for (const key of Object.keys(settingsProps)) {
+            if (key in parsed)
+                settingsData[key] = parsed[key];
+        }
+        const rawSchema = (0, schemaUtils_1.loadRawSchema)();
+        const result = (0, schemaUtils_1.validateAgainstSchema)({
+            type: 'object',
+            properties: settingsProps,
+            required: (pipelineDef?.required || []).filter((r) => r in settingsProps),
+            $defs: rawSchema.$defs,
+        }, settingsData);
+        if (result.valid) {
+            output_1.default.green(`${label}Pipeline settings`);
+        }
+        else {
+            errors += result.errors.length;
+            output_1.default.error(`${label}Pipeline settings`);
+            outputErrors(result, '  ');
+        }
+    }
+    const itemByKey = new Map(itemSections.map((s) => [s.key, s.defName]));
+    const objByKey = new Map(objectSections.map((s) => [s.key, s.defName]));
+    for (const key of Object.keys(props)) {
+        if (!(key in parsed))
+            continue;
+        const value = parsed[key];
+        const header = `${label}${prettifyKey(key)}`;
+        if (itemByKey.has(key)) {
+            if (!Array.isArray(value))
+                continue;
+            output_1.default.blue(header);
+            errors += validateItemSection(defs, value, itemByKey.get(key));
+        }
+        else if (objByKey.has(key)) {
+            if (value === null || typeof value !== 'object' || Array.isArray(value))
+                continue;
+            errors += validateObjectSection(defs, header, value, objByKey.get(key));
+        }
+    }
+    return errors;
+}
+function validatePipelineFile(file) {
+    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;
+    }
+    const YAML = require('yaml');
+    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+    let parsed;
+    try {
+        parsed = YAML.parse(content);
+    }
+    catch (e) {
+        output_1.default.exitError(`YAML parse error: ${e.message}`);
+        return;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        output_1.default.exitError('Invalid pipeline YAML: expected an array of pipeline objects');
+        return;
+    }
+    if (!Array.isArray(parsed)) {
+        output_1.default.exitError('Invalid pipeline YAML: expected an array (e.g. "- pipeline: my-pipeline"), got a plain object');
+        return;
+    }
+    if (parsed.length === 0) {
+        output_1.default.exitError('Invalid pipeline YAML: empty array');
+        return;
+    }
+    let errors = 0;
+    for (let i = 0; i < parsed.length; i++) {
+        const pipeline = parsed[i];
+        if (!pipeline || typeof pipeline !== 'object' || Array.isArray(pipeline)) {
+            output_1.default.error(`  Pipeline #${i + 1}: expected an object`);
+            errors++;
+            continue;
+        }
+        const pipelineLabel = parsed.length > 1 ? `[${pipeline.pipeline || i + 1}] ` : '';
+        errors += validateSinglePipeline(pipeline, pipelineLabel);
+    }
+    output_1.default.normal('');
+    if (errors > 0) {
+        output_1.default.exitError(`${texts_1.ERR_YAML_VALIDATE_FAILED} (${errors} ${errors === 1 ? 'error' : 'errors'})`);
+    }
+    else {
+        output_1.default.exitSuccess(texts_1.TXT_YAML_VALIDATE_ALL_PASS);
+    }
+}
+const commandYamlValidate = (0, utils_1.newCommand)('validate', texts_1.DESC_COMMAND_YAML_VALIDATE);
+commandYamlValidate.argument('<file>', texts_1.OPTION_YAML_VALIDATE_FILE);
+commandYamlValidate.action(async (file) => {
+    await (0, schemaUtils_1.ensureYamlSchema)();
+    validatePipelineFile(file);
+});
+exports.default = commandYamlValidate;

package/distTs/src/command/yaml.js

@@ -0,0 +1,18 @@
+"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 pipeline_1 = __importDefault(require("./yaml/pipeline"));
+const actions_1 = __importDefault(require("./yaml/actions"));
+const validate_1 = __importDefault(require("./yaml/validate"));
+const init_1 = __importDefault(require("./yaml/init"));
+const commandYaml = (0, utils_1.newCommand)('yaml', texts_1.DESC_COMMAND_YAML);
+commandYaml.addCommand(pipeline_1.default);
+commandYaml.addCommand(actions_1.default);
+commandYaml.addCommand(validate_1.default);
+commandYaml.addCommand(init_1.default);
+commandYaml.addHelpText('after', texts_1.EXAMPLE_YAML);
+exports.default = commandYaml;

package/distTs/src/diskCache.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_TTL_MS = void 0;
+exports.cacheRoot = cacheRoot;
+exports.hashKey = hashKey;
+exports.cachePaths = cachePaths;
+exports.readMeta = readMeta;
+exports.isHardFresh = isHardFresh;
+exports.writeAtomic = writeAtomic;
+exports.refresh = refresh;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const undici_1 = require("undici");
+const utils_1 = require("./utils");
+exports.CACHE_TTL_MS = 60 * 60 * 1000; // 1h
+function cacheRoot() {
+    const dir = node_path_1.default.join((0, utils_1.getHomeDirectory)(), 'cache');
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return dir;
+}
+function hashKey(input) {
+    return (0, node_crypto_1.createHash)('sha256').update(input).digest('hex').slice(0, 16);
+}
+function cachePaths(subdir, url) {
+    const dir = node_path_1.default.join(cacheRoot(), subdir);
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const key = hashKey(url);
+    return {
+        raw: node_path_1.default.join(dir, `${key}.json`),
+        schema: node_path_1.default.join(dir, `${key}.v8`),
+        meta: node_path_1.default.join(dir, `${key}.meta.json`),
+    };
+}
+function readMeta(metaPath) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(metaPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function isHardFresh(meta, ttlMs = exports.CACHE_TTL_MS) {
+    return !!meta.fetchedAt && Date.now() - meta.fetchedAt < ttlMs;
+}
+function writeAtomic(filePath, data) {
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, data);
+    (0, node_fs_1.renameSync)(tmp, filePath);
+}
+async function refresh(url, paths) {
+    const hasRaw = (0, node_fs_1.existsSync)(paths.raw);
+    const meta = hasRaw ? readMeta(paths.meta) : {};
+    // The server serves a strong content-based ETag, so revalidate with If-None-Match.
+    const headers = {};
+    if (hasRaw && meta.etag)
+        headers['if-none-match'] = meta.etag;
+    try {
+        const res = await (0, undici_1.request)(url, { headers });
+        const etag = res.headers['etag'];
+        if (res.statusCode === 304 && hasRaw) {
+            await res.body.dump();
+            writeAtomic(paths.meta, JSON.stringify({ etag: meta.etag, fetchedAt: Date.now() }));
+            return 'unchanged';
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+            writeAtomic(paths.raw, await res.body.text());
+            writeAtomic(paths.meta, JSON.stringify({ etag: typeof etag === 'string' ? etag : undefined, fetchedAt: Date.now() }));
+            return 'updated';
+        }
+        await res.body.dump();
+    }
+    catch {
+        // network error — fall back to the cached body if present
+    }
+    return hasRaw ? 'unchanged' : 'none';
+}

package/distTs/src/input.js

@@ -1087,6 +1087,54 @@ class Input {
             return distro_1.SCOPE.PROJECT;
         return distro_1.SCOPE.WORKSPACE;
     }
+    static targetScope(project, pipeline, environment, scope) {
+        Input.targetLine(project, pipeline, environment);
+        if (scope) {
+            scope = scope.toUpperCase();
+            if (scope === utils_1.TARGET_SCOPE.WORKSPACE) {
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.PROJECT) {
+                if (!project)
+                    output_1.default.exitError(texts_1.ERR_COMMAND_SCOPE_NO_PROJECT);
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.PIPELINE) {
+                if (!pipeline)
+                    output_1.default.exitError(texts_1.ERR_TARGET_SCOPE_NO_PIPELINE);
+                return scope;
+            }
+            if (scope === utils_1.TARGET_SCOPE.ENVIRONMENT) {
+                if (!environment)
+                    output_1.default.exitError(texts_1.ERR_TARGET_SCOPE_NO_ENVIRONMENT);
+                return scope;
+            }
+            return output_1.default.exitError(texts_1.ERR_TARGET_SCOPE);
+        }
+        if (pipeline)
+            return utils_1.TARGET_SCOPE.PIPELINE;
+        if (environment)
+            return utils_1.TARGET_SCOPE.ENVIRONMENT;
+        if (project)
+            return utils_1.TARGET_SCOPE.PROJECT;
+        return utils_1.TARGET_SCOPE.WORKSPACE;
+    }
+    // Line context for resolving a target identifier via /identifiers:
+    // params describe one line from workspace down (ws -> project -> pipeline
+    // or environment), searched from the deepest scope up.
+    static targetLine(project, pipeline, environment) {
+        if (pipeline && !project) {
+            output_1.default.exitError(texts_1.ERR_TARGET_PIPELINE_REQUIRES_PROJECT);
+        }
+        if (pipeline && environment) {
+            output_1.default.exitError(texts_1.ERR_TARGET_PIPELINE_ENV_CONFLICT);
+        }
+        return {
+            project: project || undefined,
+            pipeline,
+            environment,
+        };
+    }
     static restApiProject(project, allowNull) {
         const ProjectCfg = require('./project/cfg').default;
         let p = process.env.BUDDY_PROJECT;
@@ -1107,6 +1155,12 @@ class Input {
             output_1.default.exitError(texts_1.ERR_SANDBOX_BOOT_SCRIPT_NOT_EXISTS);
         return node_fs_1.default.readFileSync(p, 'utf8');
     }
+    static tags(tags) {
+        return tags
+            .split(',')
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
     static restApiYaml(yaml) {
         if (!yaml)
             output_1.default.exitError(texts_1.ERR_REST_API_YAML);