@pipeline-builder/pipeline-manager 3.1.0

package/dist/commands/upload-plugin.js

@@ -0,0 +1,311 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadPlugin = uploadPlugin;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const ora_1 = __importDefault(require("ora"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const cli_constants_1 = require("../config/cli.constants");
+const command_utils_1 = require("../utils/command-utils");
+const error_handler_1 = require("../utils/error-handler");
+const output_utils_1 = require("../utils/output-utils");
+const { bold, green } = picocolors_1.default;
+/**
+ * Registers the `upload-plugin` command with the CLI program.
+ *
+ * Validates a local plugin ZIP file (size, extension, readability),
+ * builds a multipart form, and uploads it to the platform API.
+ * Plugin name and version can be auto-detected from the package
+ * or overridden via CLI flags.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * cli upload-plugin --file plugin.zip --organization acme
+ * cli upload-plugin --file plugin.zip --organization acme --public
+ * cli upload-plugin --file plugin.zip --organization acme --name my-plugin --version 1.0.0
+ * cli upload-plugin --file plugin.zip --organization acme --no-verify-ssl
+ * ```
+ */
+function uploadPlugin(program) {
+    program
+        .command('upload-plugin')
+        .description('Upload and deploy a plugin package')
+        .requiredOption('-f, --file <file>', 'Path to plugin ZIP file')
+        .requiredOption('-o, --organization <organization>', 'Organization name')
+        .option('-n, --name <name>', 'Plugin name (optional, extracted from package if not provided)')
+        .option('-v, --version <version>', 'Plugin version (optional, extracted from package if not provided)')
+        .option('--public', 'Make plugin publicly accessible', false)
+        .option('--active', 'Set plugin as active', true)
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification')
+        .option('--dry-run', 'Validate file without uploading', false)
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('Upload Plugin');
+        try {
+            // Display parameters
+            (0, output_utils_1.printInfo)('Upload parameters', {
+                file: options.file,
+                organization: options.organization,
+                name: options.name || '(auto-detect)',
+                version: options.version || '(auto-detect)',
+                public: options.public ? 'Yes' : 'No',
+                active: options.active ? 'Yes' : 'No',
+                dryRun: options.dryRun,
+                verifySsl: options.verifySsl,
+            });
+            // Security warning for SSL verification disabled
+            (0, command_utils_1.printSslWarning)(options.verifySsl);
+            // Validate organization
+            if (!options.organization || typeof options.organization !== 'string' || options.organization.trim().length === 0) {
+                (0, output_utils_1.printError)('Invalid organization name', { provided: options.organization });
+                throw new error_handler_1.ValidationError('Organization must be a non-empty string', 'organization', options.organization);
+            }
+            // Validate file path
+            if (!options.file || typeof options.file !== 'string' || options.file.trim().length === 0) {
+                (0, output_utils_1.printError)('Invalid file path', { provided: options.file });
+                throw new error_handler_1.ValidationError('File path must be a non-empty string', 'file', options.file);
+            }
+            const filePath = path.resolve(options.file);
+            // Validate file exists
+            (0, output_utils_1.printInfo)('Validating plugin file', { path: filePath });
+            if (!(0, output_utils_1.fileExists)(filePath)) {
+                (0, output_utils_1.printError)('Plugin file not found', { path: filePath });
+                throw new error_handler_1.ValidationError(`Plugin file not found: ${filePath}`, 'file', filePath);
+            }
+            // Validate file extension
+            const fileExt = path.extname(filePath).toLowerCase();
+            if (fileExt !== '.zip') {
+                (0, output_utils_1.printWarning)('File extension is not .zip', {
+                    provided: fileExt,
+                    expected: '.zip',
+                });
+                throw new error_handler_1.ValidationError('Plugin file must be a ZIP archive', 'file', filePath);
+            }
+            // Get file stats
+            const stats = fs.statSync(filePath);
+            const sizeBytes = stats.size;
+            const sizeFormatted = (0, cli_constants_1.formatFileSize)(sizeBytes);
+            (0, output_utils_1.printSuccess)('Plugin file found', {
+                path: filePath,
+                size: sizeFormatted,
+                modified: new Date(stats.mtime).toLocaleString(),
+            });
+            // Check file size
+            if (sizeBytes > cli_constants_1.FILE_SIZE_LIMITS.PLUGIN) {
+                (0, output_utils_1.printError)('Plugin file too large', {
+                    size: sizeFormatted,
+                    maximum: (0, cli_constants_1.formatFileSize)(cli_constants_1.FILE_SIZE_LIMITS.PLUGIN),
+                    exceededBy: (0, cli_constants_1.formatFileSize)(sizeBytes - cli_constants_1.FILE_SIZE_LIMITS.PLUGIN),
+                });
+                throw new error_handler_1.ValidationError(`Plugin file exceeds maximum size of ${(0, cli_constants_1.formatFileSize)(cli_constants_1.FILE_SIZE_LIMITS.PLUGIN)} (actual: ${sizeFormatted})`, 'file.size', sizeBytes);
+            }
+            // Check if file is readable
+            try {
+                fs.accessSync(filePath, fs.constants.R_OK);
+            }
+            catch (error) {
+                (0, output_utils_1.printError)('Cannot read plugin file', {
+                    path: filePath,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw new error_handler_1.ValidationError('Plugin file is not readable', 'file', filePath);
+            }
+            (0, output_utils_1.printSuccess)('Plugin file validated');
+            // Validate version format if provided
+            if (options.version) {
+                const versionRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+                if (!versionRegex.test(options.version)) {
+                    (0, output_utils_1.printWarning)('Version format may be invalid', {
+                        provided: options.version,
+                        expected: 'semantic version (e.g., 1.0.0, 1.2.3-beta.1)',
+                    });
+                }
+            }
+            // Validate name format if provided
+            if (options.name) {
+                const nameRegex = /^[a-z0-9-]+$/;
+                if (!nameRegex.test(options.name)) {
+                    (0, output_utils_1.printWarning)('Plugin name format may be invalid', {
+                        provided: options.name,
+                        expected: 'lowercase alphanumeric with dashes (e.g., my-plugin-name)',
+                    });
+                }
+            }
+            // Dry run mode
+            if (options.dryRun) {
+                console.log('');
+                (0, output_utils_1.printSection)('Dry Run - Validation Complete');
+                (0, output_utils_1.printSuccess)('File validation passed - no upload performed');
+                (0, output_utils_1.printKeyValue)({
+                    File: filePath,
+                    Size: sizeFormatted,
+                    Organization: options.organization,
+                    Name: options.name || '(will be auto-detected)',
+                    Version: options.version || '(will be auto-detected)',
+                    Public: options.public ? 'Yes' : 'No',
+                    Active: options.active ? 'Yes' : 'No',
+                });
+                return;
+            }
+            // Create authenticated API client
+            const client = (0, command_utils_1.createAuthenticatedClient)(options);
+            const config = client.getConfig();
+            // Create form data
+            console.log('');
+            (0, output_utils_1.printSection)('Uploading Plugin');
+            (0, output_utils_1.printInfo)('Preparing upload', {
+                file: path.basename(filePath),
+                size: sizeFormatted,
+            });
+            const formData = new form_data_1.default();
+            formData.append('plugin', fs.createReadStream(filePath), {
+                filename: path.basename(filePath),
+                contentType: 'application/zip',
+            });
+            formData.append('organization', options.organization);
+            if (options.name)
+                formData.append('name', options.name);
+            if (options.version)
+                formData.append('version', options.version);
+            formData.append('isPublic', options.public ? 'true' : 'false');
+            formData.append('isActive', options.active ? 'true' : 'false');
+            // Make API request
+            const endpoint = config.api.pluginUploadUrl;
+            (0, output_utils_1.printInfo)('Uploading to API', {
+                endpoint: `${config.api.baseUrl}${endpoint}`,
+            });
+            console.log('');
+            const spinner = (0, ora_1.default)('Uploading plugin...').start();
+            let rawResponse;
+            let duration;
+            try {
+                const startTime = Date.now();
+                rawResponse = await client.postForm(endpoint, formData);
+                duration = Date.now() - startTime;
+                spinner.succeed('Plugin uploaded');
+            }
+            catch (error) {
+                spinner.fail('Upload failed');
+                throw error;
+            }
+            const response = (0, output_utils_1.extractSingleResponse)(rawResponse, 'plugin', 'name');
+            if (!response) {
+                (0, output_utils_1.printError)('No valid plugin data in response', {
+                    responseKeys: rawResponse ? Object.keys(rawResponse) : '(null)',
+                });
+                throw new Error('Upload failed - no valid plugin data received');
+            }
+            console.log('');
+            (0, output_utils_1.printSection)('Plugin Uploaded Successfully');
+            // Display plugin information
+            (0, output_utils_1.printKeyValue)({
+                'Plugin ID': green(bold(response.id)),
+                'Name': response.name,
+                'Version': response.version,
+                'Organization': response.organization,
+                'Description': response.description || '(not set)',
+            });
+            console.log('');
+            (0, output_utils_1.printKeyValue)({
+                'File URL': response.fileUrl || '(not available)',
+                'File Size': response.fileSize ? `${(response.fileSize / 1024).toFixed(2)} KB` : '(not available)',
+                'Checksum': response.checksum ? `${response.checksum.substring(0, 16)}...` : '(not available)',
+            });
+            console.log('');
+            (0, output_utils_1.printKeyValue)({
+                'Public': response.isPublic ? 'Yes' : 'No',
+                'Active': response.isActive ? 'Yes' : 'No',
+                'Created At': response.createdAt || '(not available)',
+                'Uploaded By': response.uploadedBy || '(not available)',
+            });
+            console.log('');
+            (0, output_utils_1.printKeyValue)({
+                'Execution ID': executionId,
+                'Upload Duration': `${(duration / 1000).toFixed(2)}s`,
+                'Status': green('✓ Success'),
+            });
+            // Print additional information if available
+            if (response.metadata) {
+                console.log('');
+                (0, output_utils_1.printInfo)('Plugin metadata available', {
+                    keys: Object.keys(response.metadata).length,
+                });
+            }
+            // Print deployment logs URL if available
+            const resp = response;
+            const requestId = resp['X-Request-Id'] || resp.requestId;
+            if (requestId) {
+                console.log('');
+                (0, output_utils_1.printInfo)('Deployment logs available', {
+                    requestId,
+                    url: `${config.api.baseUrl}/logs/${requestId}`,
+                });
+            }
+            // Next steps
+            console.log('');
+            (0, output_utils_1.printInfo)('Next steps', {
+                view: `Use "get-plugin --id ${response.id}" to view plugin details`,
+                list: 'Use "list-plugins" to see all plugins',
+            });
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'upload-plugin',
+                    executionId,
+                    file: options.file,
+                    organization: options.organization,
+                    name: options.name,
+                    version: options.version,
+                    public: options.public,
+                    active: options.active,
+                    verifySsl: options.verifySsl,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-plugin.js","sourceRoot":"","sources":["../../src/commands/upload-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { Command } from 'commander';\nimport FormData from 'form-data';\nimport ora from 'ora';\nimport pico from 'picocolors';\nimport { FILE_SIZE_LIMITS, formatFileSize } from '../config/cli.constants';\nimport { Plugin, PluginResponse } from '../types';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClient } from '../utils/command-utils';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler';\nimport { extractSingleResponse, fileExists, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils';\n\nconst { bold, green } = pico;\n\n/**\n * Registers the `upload-plugin` command with the CLI program.\n *\n * Validates a local plugin ZIP file (size, extension, readability),\n * builds a multipart form, and uploads it to the platform API.\n * Plugin name and version can be auto-detected from the package\n * or overridden via CLI flags.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * cli upload-plugin --file plugin.zip --organization acme\n * cli upload-plugin --file plugin.zip --organization acme --public\n * cli upload-plugin --file plugin.zip --organization acme --name my-plugin --version 1.0.0\n * cli upload-plugin --file plugin.zip --organization acme --no-verify-ssl\n * ```\n */\nexport function uploadPlugin(program: Command): void {\n  program\n    .command('upload-plugin')\n    .description('Upload and deploy a plugin package')\n    .requiredOption('-f, --file <file>', 'Path to plugin ZIP file')\n    .requiredOption('-o, --organization <organization>', 'Organization name')\n    .option('-n, --name <name>', 'Plugin name (optional, extracted from package if not provided)')\n    .option('-v, --version <version>', 'Plugin version (optional, extracted from package if not provided)')\n    .option('--public', 'Make plugin publicly accessible', false)\n    .option('--active', 'Set plugin as active', true)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .option('--dry-run', 'Validate file without uploading', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Upload Plugin');\n\n      try {\n\n        // Display parameters\n        printInfo('Upload parameters', {\n          file: options.file,\n          organization: options.organization,\n          name: options.name || '(auto-detect)',\n          version: options.version || '(auto-detect)',\n          public: options.public ? 'Yes' : 'No',\n          active: options.active ? 'Yes' : 'No',\n          dryRun: options.dryRun,\n          verifySsl: options.verifySsl,\n        });\n\n        // Security warning for SSL verification disabled\n        printSslWarning(options.verifySsl);\n\n        // Validate organization\n        if (!options.organization || typeof options.organization !== 'string' || options.organization.trim().length === 0) {\n          printError('Invalid organization name', { provided: options.organization });\n          throw new ValidationError('Organization must be a non-empty string', 'organization', options.organization);\n        }\n\n        // Validate file path\n        if (!options.file || typeof options.file !== 'string' || options.file.trim().length === 0) {\n          printError('Invalid file path', { provided: options.file });\n          throw new ValidationError('File path must be a non-empty string', 'file', options.file);\n        }\n\n        const filePath = path.resolve(options.file);\n\n        // Validate file exists\n        printInfo('Validating plugin file', { path: filePath });\n\n        if (!fileExists(filePath)) {\n          printError('Plugin file not found', { path: filePath });\n          throw new ValidationError(`Plugin file not found: ${filePath}`, 'file', filePath);\n        }\n\n        // Validate file extension\n        const fileExt = path.extname(filePath).toLowerCase();\n        if (fileExt !== '.zip') {\n          printWarning('File extension is not .zip', {\n            provided: fileExt,\n            expected: '.zip',\n          });\n          throw new ValidationError('Plugin file must be a ZIP archive', 'file', filePath);\n        }\n\n        // Get file stats\n        const stats = fs.statSync(filePath);\n        const sizeBytes = stats.size;\n        const sizeFormatted = formatFileSize(sizeBytes);\n\n        printSuccess('Plugin file found', {\n          path: filePath,\n          size: sizeFormatted,\n          modified: new Date(stats.mtime).toLocaleString(),\n        });\n\n        // Check file size\n        if (sizeBytes > FILE_SIZE_LIMITS.PLUGIN) {\n          printError('Plugin file too large', {\n            size: sizeFormatted,\n            maximum: formatFileSize(FILE_SIZE_LIMITS.PLUGIN),\n            exceededBy: formatFileSize(sizeBytes - FILE_SIZE_LIMITS.PLUGIN),\n          });\n          throw new ValidationError(\n            `Plugin file exceeds maximum size of ${formatFileSize(FILE_SIZE_LIMITS.PLUGIN)} (actual: ${sizeFormatted})`,\n            'file.size',\n            sizeBytes,\n          );\n        }\n\n        // Check if file is readable\n        try {\n          fs.accessSync(filePath, fs.constants.R_OK);\n        } catch (error) {\n          printError('Cannot read plugin file', {\n            path: filePath,\n            error: error instanceof Error ? error.message : String(error),\n          });\n          throw new ValidationError('Plugin file is not readable', 'file', filePath);\n        }\n\n        printSuccess('Plugin file validated');\n\n        // Validate version format if provided\n        if (options.version) {\n          const versionRegex = /^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$/;\n          if (!versionRegex.test(options.version)) {\n            printWarning('Version format may be invalid', {\n              provided: options.version,\n              expected: 'semantic version (e.g., 1.0.0, 1.2.3-beta.1)',\n            });\n          }\n        }\n\n        // Validate name format if provided\n        if (options.name) {\n          const nameRegex = /^[a-z0-9-]+$/;\n          if (!nameRegex.test(options.name)) {\n            printWarning('Plugin name format may be invalid', {\n              provided: options.name,\n              expected: 'lowercase alphanumeric with dashes (e.g., my-plugin-name)',\n            });\n          }\n        }\n\n        // Dry run mode\n        if (options.dryRun) {\n          console.log('');\n          printSection('Dry Run - Validation Complete');\n          printSuccess('File validation passed - no upload performed');\n\n          printKeyValue({\n            File: filePath,\n            Size: sizeFormatted,\n            Organization: options.organization,\n            Name: options.name || '(will be auto-detected)',\n            Version: options.version || '(will be auto-detected)',\n            Public: options.public ? 'Yes' : 'No',\n            Active: options.active ? 'Yes' : 'No',\n          });\n\n          return;\n        }\n\n        // Create authenticated API client\n        const client = createAuthenticatedClient(options);\n        const config = client.getConfig();\n\n        // Create form data\n        console.log('');\n        printSection('Uploading Plugin');\n        printInfo('Preparing upload', {\n          file: path.basename(filePath),\n          size: sizeFormatted,\n        });\n\n        const formData = new FormData();\n        formData.append('plugin', fs.createReadStream(filePath), {\n          filename: path.basename(filePath),\n          contentType: 'application/zip',\n        });\n        formData.append('organization', options.organization);\n\n        if (options.name) formData.append('name', options.name);\n        if (options.version) formData.append('version', options.version);\n        formData.append('isPublic', options.public ? 'true' : 'false');\n        formData.append('isActive', options.active ? 'true' : 'false');\n\n        // Make API request\n        const endpoint = config.api.pluginUploadUrl;\n        printInfo('Uploading to API', {\n          endpoint: `${config.api.baseUrl}${endpoint}`,\n        });\n\n        console.log('');\n\n        const spinner = ora('Uploading plugin...').start();\n        let rawResponse: PluginResponse;\n        let duration: number;\n        try {\n          const startTime = Date.now();\n          rawResponse = await client.postForm<PluginResponse>(endpoint, formData);\n          duration = Date.now() - startTime;\n          spinner.succeed('Plugin uploaded');\n        } catch (error) {\n          spinner.fail('Upload failed');\n          throw error;\n        }\n\n        const response = extractSingleResponse<Plugin>(rawResponse, 'plugin', 'name');\n\n        if (!response) {\n          printError('No valid plugin data in response', {\n            responseKeys: rawResponse ? Object.keys(rawResponse) : '(null)',\n          });\n          throw new Error('Upload failed - no valid plugin data received');\n        }\n\n        console.log('');\n        printSection('Plugin Uploaded Successfully');\n\n        // Display plugin information\n        printKeyValue({\n          'Plugin ID': green(bold(response.id)),\n          'Name': response.name,\n          'Version': response.version,\n          'Organization': response.organization,\n          'Description': response.description || '(not set)',\n        });\n\n        console.log('');\n        printKeyValue({\n          'File URL': response.fileUrl || '(not available)',\n          'File Size': response.fileSize ? `${(response.fileSize / 1024).toFixed(2)} KB` : '(not available)',\n          'Checksum': response.checksum ? `${response.checksum.substring(0, 16)}...` : '(not available)',\n        });\n\n        console.log('');\n        printKeyValue({\n          'Public': response.isPublic ? 'Yes' : 'No',\n          'Active': response.isActive ? 'Yes' : 'No',\n          'Created At': response.createdAt || '(not available)',\n          'Uploaded By': response.uploadedBy || '(not available)',\n        });\n\n        console.log('');\n        printKeyValue({\n          'Execution ID': executionId,\n          'Upload Duration': `${(duration / 1000).toFixed(2)}s`,\n          'Status': green('✓ Success'),\n        });\n\n        // Print additional information if available\n        if (response.metadata) {\n          console.log('');\n          printInfo('Plugin metadata available', {\n            keys: Object.keys(response.metadata).length,\n          });\n        }\n\n        // Print deployment logs URL if available\n        const resp = response as unknown as Record<string, unknown>;\n        const requestId = resp['X-Request-Id'] || resp.requestId;\n        if (requestId) {\n          console.log('');\n          printInfo('Deployment logs available', {\n            requestId,\n            url: `${config.api.baseUrl}/logs/${requestId}`,\n          });\n        }\n\n        // Next steps\n        console.log('');\n        printInfo('Next steps', {\n          view: `Use \"get-plugin --id ${response.id}\" to view plugin details`,\n          list: 'Use \"list-plugins\" to see all plugins',\n        });\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'upload-plugin',\n            executionId,\n            file: options.file,\n            organization: options.organization,\n            name: options.name,\n            version: options.version,\n            public: options.public,\n            active: options.active,\n            verifySsl: options.verifySsl,\n          },\n        });\n      }\n    });\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,CA0J9C"}

package/dist/commands/version.js

@@ -0,0 +1,223 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = version;
+const child_process_1 = require("child_process");
+const picocolors_1 = __importDefault(require("picocolors"));
+const cli_constants_1 = require("../config/cli.constants");
+const cdk_utils_1 = require("../utils/cdk-utils");
+const config_loader_1 = require("../utils/config-loader");
+const error_handler_1 = require("../utils/error-handler");
+const output_utils_1 = require("../utils/output-utils");
+const { bold, cyan, dim, green, magenta, red, yellow } = picocolors_1.default;
+/**
+ * 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 = (0, child_process_1.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 {
+        (0, config_loader_1.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.
+ */
+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 = (0, cli_constants_1.generateExecutionId)();
+            const cdkInfo = (0, cdk_utils_1.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: cli_constants_1.APP_NAME, version: cli_constants_1.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
+            (0, output_utils_1.printSection)('Version Information');
+            console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold('CLI Version Check'))}`);
+            console.log('');
+            (0, output_utils_1.printKeyValue)({
+                'CLI Name': bold(cli_constants_1.APP_NAME),
+                'CLI Version': green(bold(cli_constants_1.APP_VERSION)),
+            });
+            (0, output_utils_1.printDivider)();
+            // Verbose: system environment
+            if (options.verbose) {
+                (0, output_utils_1.printSection)('System Environment');
+                const systemInfo = getSystemInfo();
+                (0, output_utils_1.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,
+                });
+                (0, output_utils_1.printDivider)();
+                (0, output_utils_1.printSection)('AWS CDK');
+            }
+            // CDK information
+            if (cdkInfo.available && cdkInfo.version) {
+                if (options.verbose)
+                    (0, output_utils_1.printSuccess)('AWS CDK is installed');
+                (0, output_utils_1.printKeyValue)({
+                    'CDK Version': green(cdkInfo.version),
+                    'Status': green('✓ Available'),
+                });
+            }
+            else {
+                if (options.verbose) {
+                    (0, output_utils_1.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}`));
+                }
+                (0, output_utils_1.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) {
+                (0, output_utils_1.printDivider)();
+                (0, output_utils_1.printSection)('Configuration Status');
+                const configStatus = checkConfiguration();
+                const envStatus = getEnvironmentStatus();
+                if (configStatus.valid) {
+                    (0, output_utils_1.printSuccess)('Configuration is valid');
+                    try {
+                        const config = (0, config_loader_1.getConfig)();
+                        (0, output_utils_1.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) {
+                        (0, output_utils_1.printWarning)('Could not load full configuration');
+                    }
+                }
+                else {
+                    (0, output_utils_1.printError)('Configuration is invalid');
+                    if (configStatus.error) {
+                        console.log(red(`  Error: ${configStatus.error}`));
+                    }
+                }
+                console.log('');
+                (0, output_utils_1.printInfo)('Environment Variables');
+                (0, output_utils_1.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('');
+                    (0, output_utils_1.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
+            (0, output_utils_1.printDivider)();
+            console.log(dim(`  Execution ID: ${executionId}`));
+            console.log(dim(`  Timestamp: ${new Date().toISOString()}`));
+            console.log('');
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'version',
+                    options: {
+                        verbose: options.verbose,
+                        checkConfig: options.checkConfig,
+                        json: options.json,
+                    },
+                },
+            });
+        }
+    });
+    // Also support -v and --version flags at root level
+    program.on('option:version', () => {
+        console.log(`${cli_constants_1.APP_NAME} v${cli_constants_1.APP_VERSION}`);
+        process.exit(0);
+    });
+}
+//# 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';\nimport { getCdkInfo } from '../utils/cdk-utils';\nimport { getConfig } from '../utils/config-loader';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { printDivider, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils';\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\n  // Also support -v and --version flags at root level\n  program.on('option:version', () => {\n    console.log(`${APP_NAME} v${APP_VERSION}`);\n    process.exit(0);\n  });\n}\n"]}