@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/validate-templates.js

@@ -0,0 +1,116 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import fs from 'fs';
+import path from 'path';
+import { Command } from 'commander';
+import YAML from 'yaml';
+import { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';
+/**
+ * Register the `validate-templates` command.
+ *
+ * Usage:
+ *   pipeline-manager template validate --pipeline <uuid>
+ *   pipeline-manager template validate --plugin <name:version>
+ *   pipeline-manager template validate --file ./plugin-spec.yaml
+ */
+export function validateTemplatesCommand(program) {
+    withSslOptions(program
+        .command('validate')
+        .description('Parse and validate {{ ... }} templates in a pipeline or plugin spec')
+        .option('--pipeline <id>', 'Validate the pipeline with this ID')
+        .option('--plugin <name:version>', 'Validate the plugin with this name and version')
+        .option('--file <path>', 'Validate a local plugin-spec.yaml or pipeline.json file'))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Validate Templates');
+        try {
+            printSslWarning(options.verifySsl);
+            if (!options.pipeline && !options.plugin && !options.file) {
+                throw new Error('One of --pipeline, --plugin, or --file is required');
+            }
+            const core = await import('@pipeline-builder/pipeline-core');
+            const problems = [];
+            if (options.file) {
+                const filePath = path.resolve(options.file);
+                const text = fs.readFileSync(filePath, 'utf-8');
+                const doc = filePath.endsWith('.json') ? JSON.parse(text) : YAML.parse(text);
+                // Guess: if `pluginType` is present, treat as plugin spec; else pipeline
+                const isPlugin = typeof doc.pluginType === 'string';
+                const errors = isPlugin
+                    ? validatePluginDoc(core, doc)
+                    : validatePipelineDoc(core, doc);
+                if (errors.length)
+                    problems.push({ source: filePath, errors });
+            }
+            if (options.pipeline) {
+                printInfo('Fetching pipeline', { id: options.pipeline });
+                const client = await createAuthenticatedClientAsync(options);
+                const cfg = client.getConfig();
+                const res = await client.get(`${cfg.api.pipelineUrl}/${options.pipeline}`);
+                const doc = res.pipeline?.props
+                    ?? res.data?.pipeline?.props;
+                if (!doc)
+                    throw new Error(`Pipeline ${options.pipeline} not found`);
+                const errors = validatePipelineDoc(core, doc);
+                if (errors.length)
+                    problems.push({ source: `pipeline/${options.pipeline}`, errors });
+            }
+            if (options.plugin) {
+                const [name, version] = options.plugin.split(':');
+                if (!name || !version)
+                    throw new Error('--plugin requires <name:version> format');
+                printInfo('Fetching plugin', { name, version });
+                const client = await createAuthenticatedClientAsync(options);
+                const cfg = client.getConfig();
+                const res = await client.get(`${cfg.api.pluginUrl}/find?name=${encodeURIComponent(name)}&version=${encodeURIComponent(version)}`);
+                const doc = res.plugin
+                    ?? res.data?.plugin;
+                if (!doc)
+                    throw new Error(`Plugin ${name}:${version} not found`);
+                const errors = validatePluginDoc(core, doc);
+                if (errors.length)
+                    problems.push({ source: `plugin/${name}:${version}`, errors });
+            }
+            if (problems.length === 0) {
+                printSuccess('All templates valid', { executionId });
+                return;
+            }
+            printWarning(`Found ${problems.reduce((a, p) => a + p.errors.length, 0)} template error(s):`);
+            for (const p of problems) {
+                printError(p.source);
+                for (const e of p.errors) {
+                    console.log(`    [${e.field ?? '?'}] ${e.message}${e.code ? ` (${e.code})` : ''}`);
+                }
+            }
+            process.exit(1);
+        }
+        catch (err) {
+            handleError(err, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'validate-templates', executionId },
+            });
+        }
+    });
+}
+function validatePluginDoc(core, doc) {
+    const isTpl = (f) => f === 'description' ||
+        f.startsWith('commands') ||
+        f.startsWith('installCommands') ||
+        f.startsWith('env.') || f.startsWith('env[') ||
+        f.startsWith('buildArgs.') || f.startsWith('buildArgs[');
+    const isKnown = core.allowedScopeRoots(['pipeline', 'plugin', 'env']);
+    const { errors } = core.validateTemplates(doc, isTpl, isKnown);
+    return errors;
+}
+function validatePipelineDoc(core, doc) {
+    const isTpl = (f) => f === 'projectName' ||
+        f.startsWith('metadata.') || f.startsWith('metadata[') ||
+        f.startsWith('vars.') || f.startsWith('vars[');
+    const isKnown = core.allowedScopeRoots(['metadata', 'vars']);
+    const { errors } = core.validateTemplates(doc, isTpl, isKnown);
+    const cycles = core.detectCycles(doc, isTpl, (f) => isTpl(f) ? f : null);
+    return [...errors, ...cycles];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate-templates.js","sourceRoot":"","sources":["../../src/commands/validate-templates.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,8BAA8B,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChI,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAS7F;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAgB;IACvD,cAAc,CAAC,OAAO;SACnB,OAAO,CAAC,UAAU,CAAC;SACnB,WAAW,CAAC,qEAAqE,CAAC;SAClF,MAAM,CAAC,iBAAiB,EAAE,oCAAoC,CAAC;SAC/D,MAAM,CAAC,yBAAyB,EAAE,gDAAgD,CAAC;SACnF,MAAM,CAAC,eAAe,EAAE,yDAAyD,CAAC,CAAC;SACnF,MAAM,CAAC,KAAK,EAAE,OAAwB,EAAE,EAAE;QACzC,MAAM,WAAW,GAAG,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;QAC7D,IAAI,CAAC;YACH,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAEnC,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBAC1D,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACxE,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,iCAAiC,CAAC,CAAC;YAE7D,MAAM,QAAQ,GAA4F,EAAE,CAAC;YAE7G,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;gBACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC5C,MAAM,IAAI,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBAChD,MAAM,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAE7E,yEAAyE;gBACzE,MAAM,QAAQ,GAAG,OAAQ,GAAgC,CAAC,UAAU,KAAK,QAAQ,CAAC;gBAClF,MAAM,MAAM,GAAG,QAAQ;oBACrB,CAAC,CAAC,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC;oBAC9B,CAAC,CAAC,mBAAmB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;gBACnC,IAAI,MAAM,CAAC,MAAM;oBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;YACjE,CAAC;YAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,SAAS,CAAC,mBAAmB,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACzD,MAAM,MAAM,GAAG,MAAM,8BAA8B,CAAC,OAAO,CAAC,CAAC;gBAC7D,MAAM,GAAG,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC/B,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAoC,GAAG,GAAG,CAAC,GAAG,CAAC,WAAW,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC9G,MAAM,GAAG,GAAI,GAAyC,CAAC,QAAQ,EAAE,KAAK;uBAChE,GAAoD,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC;gBACjF,IAAI,CAAC,GAAG;oBAAE,MAAM,IAAI,KAAK,CAAC,YAAY,OAAO,CAAC,QAAQ,YAAY,CAAC,CAAC;gBACpE,MAAM,MAAM,GAAG,mBAAmB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC9C,IAAI,MAAM,CAAC,MAAM;oBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YACvF,CAAC;YAED,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;gBACnB,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAClD,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO;oBAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBAClF,SAAS,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;gBAChD,MAAM,MAAM,GAAG,MAAM,8BAA8B,CAAC,OAAO,CAAC,CAAC;gBAC7D,MAAM,GAAG,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC/B,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAC1B,GAAG,GAAG,CAAC,GAAG,CAAC,SAAS,cAAc,kBAAkB,CAAC,IAAI,CAAC,YAAY,kBAAkB,CAAC,OAAO,CAAC,EAAE,CACpG,CAAC;gBACF,MAAM,GAAG,GAAI,GAA4B,CAAC,MAAM;uBAC1C,GAAuC,CAAC,IAAI,EAAE,MAAM,CAAC;gBAC3D,IAAI,CAAC,GAAG;oBAAE,MAAM,IAAI,KAAK,CAAC,UAAU,IAAI,IAAI,OAAO,YAAY,CAAC,CAAC;gBACjE,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC5C,IAAI,MAAM,CAAC,MAAM;oBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,IAAI,IAAI,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YACpF,CAAC;YAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC1B,YAAY,CAAC,qBAAqB,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;gBACrD,OAAO;YACT,CAAC;YAED,YAAY,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,qBAAqB,CAAC,CAAC;YAC9F,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;gBACzB,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBACrB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;oBACzB,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBACrF,CAAC;YACH,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,WAAW,EAAE;gBACxC,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK;gBAC3B,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,EAAE,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE;aACxD,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAyB,EAAE,GAAY;IAChE,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAC1B,CAAC,KAAK,aAAa;QACnB,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;QACxB,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC;QAC/B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;QAC5C,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;IACtE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC/D,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,mBAAmB,CAAC,IAAyB,EAAE,GAAY;IAClE,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAC1B,CAAC,KAAK,aAAa;QACnB,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC;QACtD,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7D,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACjF,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC;AAChC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'fs';\nimport path from 'path';\nimport { Command } from 'commander';\nimport YAML from 'yaml';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\n\ninterface ValidateOptions {\n  pipeline?: string;\n  plugin?: string;\n  file?: string;\n  verifySsl?: boolean;\n}\n\n/**\n * Register the `validate-templates` command.\n *\n * Usage:\n *   pipeline-manager template validate --pipeline <uuid>\n *   pipeline-manager template validate --plugin <name:version>\n *   pipeline-manager template validate --file ./plugin-spec.yaml\n */\nexport function validateTemplatesCommand(program: Command): void {\n  withSslOptions(program\n    .command('validate')\n    .description('Parse and validate {{ ... }} templates in a pipeline or plugin spec')\n    .option('--pipeline <id>', 'Validate the pipeline with this ID')\n    .option('--plugin <name:version>', 'Validate the plugin with this name and version')\n    .option('--file <path>', 'Validate a local plugin-spec.yaml or pipeline.json file'))\n    .action(async (options: ValidateOptions) => {\n      const executionId = printCommandHeader('Validate Templates');\n      try {\n        printSslWarning(options.verifySsl);\n\n        if (!options.pipeline && !options.plugin && !options.file) {\n          throw new Error('One of --pipeline, --plugin, or --file is required');\n        }\n\n        const core = await import('@pipeline-builder/pipeline-core');\n\n        const problems: Array<{ source: string; errors: { field?: string; message: string; code?: string }[] }> = [];\n\n        if (options.file) {\n          const filePath = path.resolve(options.file);\n          const text = fs.readFileSync(filePath, 'utf-8');\n          const doc = filePath.endsWith('.json') ? JSON.parse(text) : YAML.parse(text);\n\n          // Guess: if `pluginType` is present, treat as plugin spec; else pipeline\n          const isPlugin = typeof (doc as { pluginType?: unknown }).pluginType === 'string';\n          const errors = isPlugin\n            ? validatePluginDoc(core, doc)\n            : validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: filePath, errors });\n        }\n\n        if (options.pipeline) {\n          printInfo('Fetching pipeline', { id: options.pipeline });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ pipeline?: { props: unknown } }>(`${cfg.api.pipelineUrl}/${options.pipeline}`);\n          const doc = (res as { pipeline?: { props: unknown } }).pipeline?.props\n            ?? (res as { data?: { pipeline?: { props: unknown } } }).data?.pipeline?.props;\n          if (!doc) throw new Error(`Pipeline ${options.pipeline} not found`);\n          const errors = validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: `pipeline/${options.pipeline}`, errors });\n        }\n\n        if (options.plugin) {\n          const [name, version] = options.plugin.split(':');\n          if (!name || !version) throw new Error('--plugin requires <name:version> format');\n          printInfo('Fetching plugin', { name, version });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ plugin: unknown }>(\n            `${cfg.api.pluginUrl}/find?name=${encodeURIComponent(name)}&version=${encodeURIComponent(version)}`,\n          );\n          const doc = (res as { plugin?: unknown }).plugin\n            ?? (res as { data?: { plugin?: unknown } }).data?.plugin;\n          if (!doc) throw new Error(`Plugin ${name}:${version} not found`);\n          const errors = validatePluginDoc(core, doc);\n          if (errors.length) problems.push({ source: `plugin/${name}:${version}`, errors });\n        }\n\n        if (problems.length === 0) {\n          printSuccess('All templates valid', { executionId });\n          return;\n        }\n\n        printWarning(`Found ${problems.reduce((a, p) => a + p.errors.length, 0)} template error(s):`);\n        for (const p of problems) {\n          printError(p.source);\n          for (const e of p.errors) {\n            console.log(`    [${e.field ?? '?'}] ${e.message}${e.code ? ` (${e.code})` : ''}`);\n          }\n        }\n        process.exit(1);\n      } catch (err) {\n        handleError(err, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'validate-templates', executionId },\n        });\n      }\n    });\n}\n\nfunction validatePluginDoc(core: Record<string, any>, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  const isTpl = (f: string) =>\n    f === 'description' ||\n    f.startsWith('commands') ||\n    f.startsWith('installCommands') ||\n    f.startsWith('env.') || f.startsWith('env[') ||\n    f.startsWith('buildArgs.') || f.startsWith('buildArgs[');\n  const isKnown = core.allowedScopeRoots(['pipeline', 'plugin', 'env']);\n  const { errors } = core.validateTemplates(doc, isTpl, isKnown);\n  return errors;\n}\n\nfunction validatePipelineDoc(core: Record<string, any>, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  const isTpl = (f: string) =>\n    f === 'projectName' ||\n    f.startsWith('metadata.') || f.startsWith('metadata[') ||\n    f.startsWith('vars.') || f.startsWith('vars[');\n  const isKnown = core.allowedScopeRoots(['metadata', 'vars']);\n  const { errors } = core.validateTemplates(doc, isTpl, isKnown);\n  const cycles = core.detectCycles(doc, isTpl, (f: string) => isTpl(f) ? f : null);\n  return [...errors, ...cycles];\n}\n"]}

package/dist/commands/version.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+/**
+ * Registers the `version` command with the CLI program.
+ *
+ * Displays the CLI name/version, AWS CDK status, and optionally
+ * full system diagnostics (`--verbose`) or configuration validation
+ * (`--check-config`).  Supports `--json` for machine-readable output.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function version(program: Command): void;
+//# sourceMappingURL=version.d.ts.map

package/dist/commands/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/commands/version.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoFpC;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuJ9C"}

package/dist/commands/version.js

@@ -0,0 +1,216 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { execSync } from 'child_process';
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { APP_NAME, APP_VERSION, generateExecutionId } from '../config/cli.constants.js';
+import { getCdkInfo } from '../utils/cdk-utils.js';
+import { getConfig } from '../utils/config-loader.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printDivider, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+const { bold, cyan, dim, green, magenta, red, yellow } = pico;
+/**
+ * Collects runtime system information including Node.js/npm versions,
+ * platform, architecture, heap memory usage, and process uptime.
+ */
+function getSystemInfo() {
+    const mem = process.memoryUsage();
+    const totalMem = (mem.heapTotal / 1024 / 1024).toFixed(2);
+    const availableHeap = ((mem.heapTotal - mem.heapUsed) / 1024 / 1024).toFixed(2);
+    const uptime = process.uptime();
+    let npm;
+    try {
+        npm = execSync('npm --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    }
+    catch {
+        npm = null;
+    }
+    return {
+        nodejs: process.version,
+        npm,
+        platform: process.platform,
+        architecture: process.arch,
+        memory: { total: `${totalMem} MB`, availableHeap: `${availableHeap} MB` },
+        uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m ${Math.floor(uptime % 60)}s`,
+    };
+}
+/**
+ * Attempts to load the CLI configuration and reports whether it is valid.
+ * @returns An object with `valid: true` on success, or `valid: false` with an error message.
+ */
+function checkConfiguration() {
+    try {
+        getConfig();
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Checks which key environment variables are currently set.
+ * @returns Presence flags for `PLATFORM_TOKEN`, `PLATFORM_BASE_URL`, and `CLI_CONFIG_PATH`.
+ */
+function getEnvironmentStatus() {
+    return {
+        token: !!process.env.PLATFORM_TOKEN,
+        url: !!process.env.PLATFORM_BASE_URL,
+        configPath: !!process.env.CLI_CONFIG_PATH,
+    };
+}
+/**
+ * Registers the `version` command with the CLI program.
+ *
+ * Displays the CLI name/version, AWS CDK status, and optionally
+ * full system diagnostics (`--verbose`) or configuration validation
+ * (`--check-config`).  Supports `--json` for machine-readable output.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export function version(program) {
+    program
+        .command('version')
+        .description('Display CLI version and environment information')
+        .option('--verbose', 'Show detailed environment information', false)
+        .option('--check-config', 'Verify configuration status', false)
+        .option('--json', 'Output in JSON format', false)
+        .action((options) => {
+        try {
+            const executionId = generateExecutionId();
+            const cdkInfo = getCdkInfo();
+            // JSON output
+            if (options.json) {
+                const systemInfo = getSystemInfo();
+                const configStatus = options.checkConfig ? checkConfiguration() : { valid: true };
+                const envStatus = getEnvironmentStatus();
+                console.log(JSON.stringify({
+                    cli: { name: APP_NAME, version: APP_VERSION },
+                    system: systemInfo,
+                    cdk: { available: cdkInfo.available, version: cdkInfo.version },
+                    configuration: { valid: configStatus.valid, error: configStatus.error },
+                    environment: envStatus,
+                    executionId,
+                    timestamp: new Date().toISOString(),
+                }, null, 2));
+                return;
+            }
+            // Standard output
+            printSection('Version Information');
+            console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold('CLI Version Check'))}`);
+            console.log('');
+            printKeyValue({
+                'CLI Name': bold(APP_NAME),
+                'CLI Version': green(bold(APP_VERSION)),
+            });
+            printDivider();
+            // Verbose: system environment
+            if (options.verbose) {
+                printSection('System Environment');
+                const systemInfo = getSystemInfo();
+                printKeyValue({
+                    'Node.js': systemInfo.nodejs,
+                    'npm': systemInfo.npm || yellow('(not available)'),
+                    'Platform': systemInfo.platform,
+                    'Architecture': systemInfo.architecture,
+                    'Memory (Heap)': `${systemInfo.memory.total} total, ${systemInfo.memory.availableHeap} available`,
+                    'Process Uptime': systemInfo.uptime,
+                });
+                printDivider();
+                printSection('AWS CDK');
+            }
+            // CDK information
+            if (cdkInfo.available && cdkInfo.version) {
+                if (options.verbose)
+                    printSuccess('AWS CDK is installed');
+                printKeyValue({
+                    'CDK Version': green(cdkInfo.version),
+                    'Status': green('✓ Available'),
+                });
+            }
+            else {
+                if (options.verbose) {
+                    printWarning('AWS CDK is not installed');
+                    console.log(dim('  Install CDK with: npm install -g aws-cdk'));
+                    if (cdkInfo.error)
+                        console.log(dim(`  Error: ${cdkInfo.error}`));
+                }
+                printKeyValue({
+                    'AWS CDK': red('✗ Not installed'),
+                    'Status': red('✗ Not Available'),
+                });
+            }
+            if (!options.verbose) {
+                console.log(dim('\n  Run with --verbose for detailed environment information'));
+            }
+            // Configuration check
+            if (options.checkConfig) {
+                printDivider();
+                printSection('Configuration Status');
+                const configStatus = checkConfiguration();
+                const envStatus = getEnvironmentStatus();
+                if (configStatus.valid) {
+                    printSuccess('Configuration is valid');
+                    try {
+                        const config = getConfig();
+                        printKeyValue({
+                            'API Base URL': config.api.baseUrl,
+                            'SSL Verification': config.api.rejectUnauthorized ? green('Enabled') : yellow('Disabled'),
+                            'Timeout': `${config.api.timeout}ms`,
+                            'Authenticated': config.auth.token ? green('Yes') : red('No'),
+                        });
+                    }
+                    catch (error) {
+                        printWarning('Could not load full configuration');
+                    }
+                }
+                else {
+                    printError('Configuration is invalid');
+                    if (configStatus.error) {
+                        console.log(red(`  Error: ${configStatus.error}`));
+                    }
+                }
+                console.log('');
+                printInfo('Environment Variables');
+                printKeyValue({
+                    PLATFORM_TOKEN: envStatus.token ? green('✓ Set') : red('✗ Not set'),
+                    PLATFORM_BASE_URL: envStatus.url ? green('✓ Set') : dim('(not set - using default)'),
+                    CLI_CONFIG_PATH: envStatus.configPath ? green('✓ Set') : dim('(not set - using default)'),
+                });
+                if (!envStatus.token) {
+                    console.log('');
+                    printWarning('PLATFORM_TOKEN is required for API operations');
+                    console.log(dim('  Set it with: export PLATFORM_TOKEN="your-token-here"'));
+                }
+            }
+            else {
+                console.log(dim('\n  💡 Tip: Run with --check-config to verify configuration'));
+            }
+            // Footer
+            printDivider();
+            console.log(dim(`  Execution ID: ${executionId}`));
+            console.log(dim(`  Timestamp: ${new Date().toISOString()}`));
+            console.log('');
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'version',
+                    options: {
+                        verbose: options.verbose,
+                        checkConfig: options.checkConfig,
+                        json: options.json,
+                    },
+                },
+            });
+        }
+    });
+    // NOTE: `-v`/`--version` is handled by commander's own `.version(...)` in
+    // cli.ts (registered first, so it exits before any custom option:version
+    // listener would run) — a duplicate listener here was dead code.
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/commands/version.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { execSync } from 'child_process';\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { APP_NAME, APP_VERSION, generateExecutionId } from '../config/cli.constants.js';\nimport { getCdkInfo } from '../utils/cdk-utils.js';\nimport { getConfig } from '../utils/config-loader.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printDivider, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\n\nconst { bold, cyan, dim, green, magenta, red, yellow } = pico;\n\n/**\n * Runtime system information collected for the `version --verbose` output.\n */\ninterface SystemInfo {\n  nodejs: string;\n  npm: string | null;\n  platform: string;\n  architecture: string;\n  memory: {\n    total: string;\n    availableHeap: string;\n  };\n  uptime: string;\n}\n\n/**\n * Collects runtime system information including Node.js/npm versions,\n * platform, architecture, heap memory usage, and process uptime.\n */\nfunction getSystemInfo(): SystemInfo {\n  const mem = process.memoryUsage();\n  const totalMem = (mem.heapTotal / 1024 / 1024).toFixed(2);\n  const availableHeap = ((mem.heapTotal - mem.heapUsed) / 1024 / 1024).toFixed(2);\n  const uptime = process.uptime();\n\n  let npm: string | null;\n  try {\n    npm = execSync('npm --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();\n  } catch {\n    npm = null;\n  }\n\n  return {\n    nodejs: process.version,\n    npm,\n    platform: process.platform,\n    architecture: process.arch,\n    memory: { total: `${totalMem} MB`, availableHeap: `${availableHeap} MB` },\n    uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m ${Math.floor(uptime % 60)}s`,\n  };\n}\n\n/**\n * Attempts to load the CLI configuration and reports whether it is valid.\n * @returns An object with `valid: true` on success, or `valid: false` with an error message.\n */\nfunction checkConfiguration(): { valid: boolean; error?: string } {\n  try {\n    getConfig();\n    return { valid: true };\n  } catch (error) {\n    return {\n      valid: false,\n      error: error instanceof Error ? error.message : String(error),\n    };\n  }\n}\n\n/**\n * Checks which key environment variables are currently set.\n * @returns Presence flags for `PLATFORM_TOKEN`, `PLATFORM_BASE_URL`, and `CLI_CONFIG_PATH`.\n */\nfunction getEnvironmentStatus(): {\n  token: boolean;\n  url: boolean;\n  configPath: boolean;\n} {\n  return {\n    token: !!process.env.PLATFORM_TOKEN,\n    url: !!process.env.PLATFORM_BASE_URL,\n    configPath: !!process.env.CLI_CONFIG_PATH,\n  };\n}\n\n/**\n * Registers the `version` command with the CLI program.\n *\n * Displays the CLI name/version, AWS CDK status, and optionally\n * full system diagnostics (`--verbose`) or configuration validation\n * (`--check-config`).  Supports `--json` for machine-readable output.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function version(program: Command): void {\n  program\n    .command('version')\n    .description('Display CLI version and environment information')\n    .option('--verbose', 'Show detailed environment information', false)\n    .option('--check-config', 'Verify configuration status', false)\n    .option('--json', 'Output in JSON format', false)\n    .action((options) => {\n      try {\n        const executionId = generateExecutionId();\n        const cdkInfo = getCdkInfo();\n\n        // JSON output\n        if (options.json) {\n          const systemInfo = getSystemInfo();\n          const configStatus = options.checkConfig ? checkConfiguration() : { valid: true };\n          const envStatus = getEnvironmentStatus();\n\n          console.log(JSON.stringify({\n            cli: { name: APP_NAME, version: APP_VERSION },\n            system: systemInfo,\n            cdk: { available: cdkInfo.available, version: cdkInfo.version },\n            configuration: { valid: configStatus.valid, error: configStatus.error },\n            environment: envStatus,\n            executionId,\n            timestamp: new Date().toISOString(),\n          }, null, 2));\n          return;\n        }\n\n        // Standard output\n        printSection('Version Information');\n        console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold('CLI Version Check'))}`);\n        console.log('');\n\n        printKeyValue({\n          'CLI Name': bold(APP_NAME),\n          'CLI Version': green(bold(APP_VERSION)),\n        });\n\n        printDivider();\n\n        // Verbose: system environment\n        if (options.verbose) {\n          printSection('System Environment');\n          const systemInfo = getSystemInfo();\n          printKeyValue({\n            'Node.js': systemInfo.nodejs,\n            'npm': systemInfo.npm || yellow('(not available)'),\n            'Platform': systemInfo.platform,\n            'Architecture': systemInfo.architecture,\n            'Memory (Heap)': `${systemInfo.memory.total} total, ${systemInfo.memory.availableHeap} available`,\n            'Process Uptime': systemInfo.uptime,\n          });\n          printDivider();\n          printSection('AWS CDK');\n        }\n\n        // CDK information\n        if (cdkInfo.available && cdkInfo.version) {\n          if (options.verbose) printSuccess('AWS CDK is installed');\n          printKeyValue({\n            'CDK Version': green(cdkInfo.version),\n            'Status': green('✓ Available'),\n          });\n        } else {\n          if (options.verbose) {\n            printWarning('AWS CDK is not installed');\n            console.log(dim('  Install CDK with: npm install -g aws-cdk'));\n            if (cdkInfo.error) console.log(dim(`  Error: ${cdkInfo.error}`));\n          }\n          printKeyValue({\n            'AWS CDK': red('✗ Not installed'),\n            'Status': red('✗ Not Available'),\n          });\n        }\n\n        if (!options.verbose) {\n          console.log(dim('\\n  Run with --verbose for detailed environment information'));\n        }\n\n        // Configuration check\n        if (options.checkConfig) {\n          printDivider();\n          printSection('Configuration Status');\n\n          const configStatus = checkConfiguration();\n          const envStatus = getEnvironmentStatus();\n\n          if (configStatus.valid) {\n            printSuccess('Configuration is valid');\n\n            try {\n              const config = getConfig();\n              printKeyValue({\n                'API Base URL': config.api.baseUrl,\n                'SSL Verification': config.api.rejectUnauthorized ? green('Enabled') : yellow('Disabled'),\n                'Timeout': `${config.api.timeout}ms`,\n                'Authenticated': config.auth.token ? green('Yes') : red('No'),\n              });\n            } catch (error) {\n              printWarning('Could not load full configuration');\n            }\n          } else {\n            printError('Configuration is invalid');\n            if (configStatus.error) {\n              console.log(red(`  Error: ${configStatus.error}`));\n            }\n          }\n\n          console.log('');\n          printInfo('Environment Variables');\n          printKeyValue({\n            PLATFORM_TOKEN: envStatus.token ? green('✓ Set') : red('✗ Not set'),\n            PLATFORM_BASE_URL: envStatus.url ? green('✓ Set') : dim('(not set - using default)'),\n            CLI_CONFIG_PATH: envStatus.configPath ? green('✓ Set') : dim('(not set - using default)'),\n          });\n\n          if (!envStatus.token) {\n            console.log('');\n            printWarning('PLATFORM_TOKEN is required for API operations');\n            console.log(dim('  Set it with: export PLATFORM_TOKEN=\"your-token-here\"'));\n          }\n        } else {\n          console.log(dim('\\n  💡 Tip: Run with --check-config to verify configuration'));\n        }\n\n        // Footer\n        printDivider();\n        console.log(dim(`  Execution ID: ${executionId}`));\n        console.log(dim(`  Timestamp: ${new Date().toISOString()}`));\n        console.log('');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'version',\n            options: {\n              verbose: options.verbose,\n              checkConfig: options.checkConfig,\n              json: options.json,\n            },\n          },\n        });\n      }\n    });\n  // NOTE: `-v`/`--version` is handled by commander's own `.version(...)` in\n  // cli.ts (registered first, so it exits before any custom option:version\n  // listener would run) — a duplicate listener here was dead code.\n}\n"]}

package/dist/config/cli.constants.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Application metadata
+ */
+export declare const APP_NAME = "pipeline-manager";
+export declare const APP_VERSION: string;
+export declare const APP_DESCRIPTION = "A CLI tool to manage pipelines and plugins";
+/**
+ * Banner configuration for CLI startup
+ */
+export declare const BANNER_OPTIONS: {
+    readonly font: 'Doom';
+    readonly horizontalLayout: 'fitted';
+    readonly getWidth: () => number;
+};
+/**
+ * Output format types
+ */
+export type OutputFormat = 'table' | 'json' | 'yaml' | 'csv';
+/**
+ * Default timeouts (in milliseconds)
+ */
+export declare const TIMEOUTS: {
+    readonly HTTP_REQUEST: 30000;
+    readonly HEALTH_CHECK: 5000;
+};
+/**
+ * File size limits (in bytes)
+ */
+export declare const FILE_SIZE_LIMITS: {
+    readonly PLUGIN: number;
+    readonly PIPELINE_PROPS: number;
+};
+/**
+ * Environment variable names
+ */
+export declare const ENV_VARS: {
+    readonly PLATFORM_TOKEN: 'PLATFORM_TOKEN';
+    readonly PLATFORM_BASE_URL: 'PLATFORM_BASE_URL';
+    readonly CLI_CONFIG_PATH: 'CLI_CONFIG_PATH';
+    readonly TLS_REJECT_UNAUTHORIZED: 'TLS_REJECT_UNAUTHORIZED';
+    readonly AWS_REGION: 'AWS_REGION';
+    readonly DEBUG: 'DEBUG';
+};
+/**
+ * Check if debug mode is enabled
+ */
+export declare function isDebugMode(options?: {
+    debug?: boolean;
+}): boolean;
+/**
+ * Format file size for display
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Format duration for display
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Generate cryptographically random execution ID for request tracing.
+ */
+export declare function generateExecutionId(): string;
+/**
+ * Table display options (box-drawing characters)
+ */
+export declare const TABLE_OPTIONS: {
+    readonly border: {
+        readonly topBody: '─';
+        readonly topJoin: '┬';
+        readonly topLeft: '┌';
+        readonly topRight: '┐';
+        readonly bottomBody: '─';
+        readonly bottomJoin: '┴';
+        readonly bottomLeft: '└';
+        readonly bottomRight: '┘';
+        readonly bodyLeft: '│';
+        readonly bodyRight: '│';
+        readonly bodyJoin: '│';
+        readonly joinBody: '─';
+        readonly joinLeft: '├';
+        readonly joinRight: '┤';
+        readonly joinJoin: '┼';
+    };
+};
+/**
+ * Validate boolean string from CLI input
+ */
+export declare function validateBoolean(value: string, fieldName: string): boolean;
+/**
+ * Validate and parse a numeric CLI parameter within optional bounds.
+ */
+export declare function validateNumber(value: string | number | undefined | null, fieldName: string, min?: number, max?: number): number;
+export declare function validateSort(value: string | undefined): string | undefined;
+export declare function assertShellSafe(value: string, fieldName: string, opts?: {
+    redactValue?: boolean;
+}): void;
+/**
+ * POSIX single-quote a value (escaping embedded single quotes) for safe shell
+ * interpolation. Single source of truth — drift in a shell-quoting helper is
+ * security-relevant, so both agent modules import this rather than re-declaring it.
+ */
+export declare function shellQuote(value: string): string;
+/**
+ * Canonical default pipeline name when none is given — MUST mirror pipeline-core's
+ * pipeline-configuration.ts (`${sanitize(org)}-${sanitize(project)}-pipeline`,
+ * non-alphanumeric → '_', lowercased), so the CLI's create and registry paths
+ * derive the SAME name the CDK builder actually deploys (a mismatch breaks
+ * StartPipelineExecution against the registered name).
+ */
+export declare function defaultPipelineName(organization: string, project: string): string;
+/**
+ * CloudFormation stack name for the event-ingestion infra. Shared so `setup-events`
+ * (which deploys it) and `redrive-events` (which resolves the DLQ/queue from it)
+ * can never drift apart.
+ */
+export declare const EVENTS_STACK_NAME = "pipeline-builder-events";
+//# sourceMappingURL=cli.constants.d.ts.map

package/dist/config/cli.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.constants.d.ts","sourceRoot":"","sources":["../../src/config/cli.constants.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,eAAO,MAAM,QAAQ,qBAAqB,CAAC;AAC3C,eAAO,MAAM,WAAW,QAAU,CAAC;AACnC,eAAO,MAAM,eAAe,+CAA+C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,cAAc;aACzB,IAAI,EAAE,MAAM;aACZ,gBAAgB,EAAE,QAAQ;aAC1B,QAAQ;CACA,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,QAAQ;aACnB,YAAY,EAAE,KAAK;aACnB,YAAY,EAAE,IAAI;CACV,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB;aAC3B,MAAM;aACN,cAAc;CACN,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,QAAQ;aACnB,cAAc,EAAE,gBAAgB;aAChC,iBAAiB,EAAE,mBAAmB;aACtC,eAAe,EAAE,iBAAiB;aAClC,uBAAuB,EAAE,yBAAyB;aAClD,UAAU,EAAE,YAAY;aACxB,KAAK,EAAE,OAAO;CACN,CAAC;AAEX;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAElE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;aACxB,MAAM;iBACJ,OAAO,EAAE,GAAG;iBACZ,OAAO,EAAE,GAAG;iBACZ,OAAO,EAAE,GAAG;iBACZ,QAAQ,EAAE,GAAG;iBACb,UAAU,EAAE,GAAG;iBACf,UAAU,EAAE,GAAG;iBACf,UAAU,EAAE,GAAG;iBACf,WAAW,EAAE,GAAG;iBAChB,QAAQ,EAAE,GAAG;iBACb,SAAS,EAAE,GAAG;iBACd,QAAQ,EAAE,GAAG;iBACb,QAAQ,EAAE,GAAG;iBACb,QAAQ,EAAE,GAAG;iBACb,SAAS,EAAE,GAAG;iBACd,QAAQ,EAAE,GAAG;;CAEP,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAKzE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB/H;AAQD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM1E;AAQD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,IAAI,CAON;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAGjF;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,4BAA4B,CAAC"}