@pipeline-builder/pipeline-manager 3.1.0

package/dist/commands/bootstrap.js

@@ -0,0 +1,159 @@
+"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.resolveAccount = resolveAccount;
+exports.resolveRegion = resolveRegion;
+exports.buildBootstrapCommand = buildBootstrapCommand;
+exports.bootstrap = bootstrap;
+const picocolors_1 = __importDefault(require("picocolors"));
+const cli_constants_1 = require("../config/cli.constants");
+const audit_log_1 = require("../utils/audit-log");
+const cdk_utils_1 = require("../utils/cdk-utils");
+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, cyan, dim } = picocolors_1.default;
+/**
+ * Resolves the AWS account ID from the CLI option or environment variable.
+ * @returns The account ID string, or `undefined` if not available.
+ */
+/** @internal Exported for testing only */
+function resolveAccount(optionValue) {
+    return optionValue || process.env.AWS_ACCOUNT_ID || process.env.CDK_DEFAULT_ACCOUNT;
+}
+/**
+ * Resolves the AWS region from the CLI option or environment variable.
+ * @returns The region string, or `undefined` if not available.
+ */
+/** @internal Exported for testing only */
+function resolveRegion(optionValue) {
+    return optionValue || process.env[cli_constants_1.ENV_VARS.AWS_REGION] || process.env.CDK_DEFAULT_REGION || 'us-east-1';
+}
+/**
+ * Builds the `cdk bootstrap` command string from the resolved options.
+ */
+/** @internal Exported for testing only */
+function buildBootstrapCommand(options) {
+    (0, cli_constants_1.assertShellSafe)(options.account, 'account');
+    (0, cli_constants_1.assertShellSafe)(options.region, 'region');
+    if (options.profile)
+        (0, cli_constants_1.assertShellSafe)(options.profile, 'profile');
+    const parts = [
+        'cdk',
+        'bootstrap',
+        `aws://${options.account}/${options.region}`,
+    ];
+    if (options.profile) {
+        parts.push(`--profile=${options.profile}`);
+    }
+    if (options.qualifier) {
+        parts.push(`--qualifier=${options.qualifier}`);
+    }
+    if (options.trust) {
+        parts.push(`--trust=${options.trust}`);
+    }
+    if (options.cloudformationExecutionPolicies) {
+        parts.push(`--cloudformation-execution-policies=${options.cloudformationExecutionPolicies}`);
+    }
+    return parts.join(' ');
+}
+/**
+ * Registers the `bootstrap` command with the CLI program.
+ *
+ * Provisions the CDK toolkit stack in the target AWS account/region
+ * so that CDK deployments can proceed.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+function bootstrap(program) {
+    program
+        .command('bootstrap')
+        .description('Bootstrap AWS CDK toolkit stack in target account/region')
+        .option('--account <id>', 'AWS account ID (defaults to AWS_ACCOUNT_ID or CDK_DEFAULT_ACCOUNT env)')
+        .option('--region <region>', 'AWS region (defaults to AWS_REGION or CDK_DEFAULT_REGION env)')
+        .option('--profile <profile>', 'AWS CLI profile', 'default')
+        .option('--qualifier <qualifier>', 'Bootstrap qualifier for environment isolation')
+        .option('--trust <accounts>', 'Comma-separated account IDs to trust for cross-account deployments')
+        .option('--cloudformation-execution-policies <arns>', 'IAM policy ARNs for CloudFormation execution role')
+        .option('--json', 'Output result as JSON', false)
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('CDK Bootstrap');
+        try {
+            (0, audit_log_1.auditLog)('bootstrap', { executionId, account: options.account, region: options.region, profile: options.profile });
+            // Resolve account and region
+            const account = resolveAccount(options.account);
+            const region = resolveRegion(options.region);
+            if (!account) {
+                (0, output_utils_1.printError)('AWS account ID is required');
+                console.log(dim('Provide --account <id> or set AWS_ACCOUNT_ID / CDK_DEFAULT_ACCOUNT environment variable'));
+                throw new Error('AWS account ID not provided');
+            }
+            (0, output_utils_1.printInfo)('Bootstrap parameters', {
+                account,
+                region,
+                profile: options.profile,
+                qualifier: options.qualifier || '(default)',
+                trust: options.trust || '(none)',
+                cloudformationExecutionPolicies: options.cloudformationExecutionPolicies || '(none)',
+            });
+            (0, cdk_utils_1.ensureCdkAvailable)();
+            (0, output_utils_1.printSuccess)('AWS CDK is available');
+            // Build bootstrap command
+            const command = buildBootstrapCommand({
+                account,
+                region,
+                profile: options.profile,
+                qualifier: options.qualifier,
+                trust: options.trust,
+                cloudformationExecutionPolicies: options.cloudformationExecutionPolicies,
+            });
+            (0, output_utils_1.printSection)('CDK Execution');
+            console.log(cyan(bold('Command:')), dim(command));
+            console.log('');
+            // Execute bootstrap
+            const result = (0, cdk_utils_1.executeCdkShellCommand)(command, {
+                debug: program.opts().debug,
+                showOutput: true,
+            });
+            console.log('');
+            (0, output_utils_1.printSection)('Bootstrap Complete');
+            if (result.success) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        executionId,
+                        account,
+                        region,
+                        duration: result.duration,
+                    }, null, 2));
+                }
+                else {
+                    (0, output_utils_1.printKeyValue)({
+                        'Execution ID': executionId,
+                        'Account': account,
+                        'Region': region,
+                        'Duration': `${result.duration}ms`,
+                        'Status': '✓ Success',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.VALIDATION, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'bootstrap',
+                    executionId,
+                    account: options.account,
+                    region: options.region,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/commands/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { ENV_VARS, assertShellSafe } from '../config/cli.constants';\nimport { auditLog } from '../utils/audit-log';\nimport { ensureCdkAvailable, executeCdkShellCommand } from '../utils/cdk-utils';\nimport { printCommandHeader } from '../utils/command-utils';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils';\n\nconst { bold, cyan, dim } = pico;\n\n/**\n * Resolves the AWS account ID from the CLI option or environment variable.\n * @returns The account ID string, or `undefined` if not available.\n */\n/** @internal Exported for testing only */\nexport function resolveAccount(optionValue?: string): string | undefined {\n  return optionValue || process.env.AWS_ACCOUNT_ID || process.env.CDK_DEFAULT_ACCOUNT;\n}\n\n/**\n * Resolves the AWS region from the CLI option or environment variable.\n * @returns The region string, or `undefined` if not available.\n */\n/** @internal Exported for testing only */\nexport function resolveRegion(optionValue?: string): string {\n  return optionValue || process.env[ENV_VARS.AWS_REGION] || process.env.CDK_DEFAULT_REGION || 'us-east-1';\n}\n\n/**\n * Builds the `cdk bootstrap` command string from the resolved options.\n */\n/** @internal Exported for testing only */\nexport function buildBootstrapCommand(options: {\n  account: string;\n  region: string;\n  profile?: string;\n  qualifier?: string;\n  trust?: string;\n  cloudformationExecutionPolicies?: string;\n}): string {\n  assertShellSafe(options.account, 'account');\n  assertShellSafe(options.region, 'region');\n  if (options.profile) assertShellSafe(options.profile, 'profile');\n\n  const parts: string[] = [\n    'cdk',\n    'bootstrap',\n    `aws://${options.account}/${options.region}`,\n  ];\n\n  if (options.profile) {\n    parts.push(`--profile=${options.profile}`);\n  }\n\n  if (options.qualifier) {\n    parts.push(`--qualifier=${options.qualifier}`);\n  }\n\n  if (options.trust) {\n    parts.push(`--trust=${options.trust}`);\n  }\n\n  if (options.cloudformationExecutionPolicies) {\n    parts.push(`--cloudformation-execution-policies=${options.cloudformationExecutionPolicies}`);\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Registers the `bootstrap` command with the CLI program.\n *\n * Provisions the CDK toolkit stack in the target AWS account/region\n * so that CDK deployments can proceed.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function bootstrap(program: Command): void {\n  program\n    .command('bootstrap')\n    .description('Bootstrap AWS CDK toolkit stack in target account/region')\n    .option('--account <id>', 'AWS account ID (defaults to AWS_ACCOUNT_ID or CDK_DEFAULT_ACCOUNT env)')\n    .option('--region <region>', 'AWS region (defaults to AWS_REGION or CDK_DEFAULT_REGION env)')\n    .option('--profile <profile>', 'AWS CLI profile', 'default')\n    .option('--qualifier <qualifier>', 'Bootstrap qualifier for environment isolation')\n    .option('--trust <accounts>', 'Comma-separated account IDs to trust for cross-account deployments')\n    .option('--cloudformation-execution-policies <arns>', 'IAM policy ARNs for CloudFormation execution role')\n    .option('--json', 'Output result as JSON', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Bootstrap');\n\n      try {\n        auditLog('bootstrap', { executionId, account: options.account, region: options.region, profile: options.profile });\n\n        // Resolve account and region\n        const account = resolveAccount(options.account);\n        const region = resolveRegion(options.region);\n\n        if (!account) {\n          printError('AWS account ID is required');\n          console.log(dim('Provide --account <id> or set AWS_ACCOUNT_ID / CDK_DEFAULT_ACCOUNT environment variable'));\n          throw new Error('AWS account ID not provided');\n        }\n\n        printInfo('Bootstrap parameters', {\n          account,\n          region,\n          profile: options.profile,\n          qualifier: options.qualifier || '(default)',\n          trust: options.trust || '(none)',\n          cloudformationExecutionPolicies: options.cloudformationExecutionPolicies || '(none)',\n        });\n\n        ensureCdkAvailable();\n        printSuccess('AWS CDK is available');\n\n        // Build bootstrap command\n        const command = buildBootstrapCommand({\n          account,\n          region,\n          profile: options.profile,\n          qualifier: options.qualifier,\n          trust: options.trust,\n          cloudformationExecutionPolicies: options.cloudformationExecutionPolicies,\n        });\n\n        printSection('CDK Execution');\n        console.log(cyan(bold('Command:')), dim(command));\n        console.log('');\n\n        // Execute bootstrap\n        const result = executeCdkShellCommand(command, {\n          debug: program.opts().debug,\n          showOutput: true,\n        });\n\n        console.log('');\n        printSection('Bootstrap Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              account,\n              region,\n              duration: result.duration,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Account': account,\n              'Region': region,\n              'Duration': `${result.duration}ms`,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.VALIDATION, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'bootstrap',\n            executionId,\n            account: options.account,\n            region: options.region,\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/create-pipeline.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+/**
+ * Registers the `create-pipeline` command with the CLI program.
+ *
+ * Accepts a pipeline properties JSON file, validates it, resolves
+ * project/organization from CLI flags or the props file, and
+ * creates the pipeline via the platform API.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function createPipeline(program: Command): void;
+//# sourceMappingURL=create-pipeline.d.ts.map

package/dist/commands/create-pipeline.d.ts.map

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

package/dist/commands/create-pipeline.js

@@ -0,0 +1,291 @@
+"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.createPipeline = createPipeline;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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, cyan, dim, green } = picocolors_1.default;
+/**
+ * Registers the `create-pipeline` command with the CLI program.
+ *
+ * Accepts a pipeline properties JSON file, validates it, resolves
+ * project/organization from CLI flags or the props file, and
+ * creates the pipeline via the platform API.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+function createPipeline(program) {
+    program
+        .command('create-pipeline')
+        .description('Create a new pipeline with the provided configuration')
+        .requiredOption('-f, --file <file>', 'Path to pipeline properties JSON file')
+        .option('-p, --project <project>', 'Project name (falls back to value in props file)')
+        .option('-o, --organization <organization>', 'Organization name (falls back to value in props file)')
+        .option('-n, --name <name>', 'Pipeline name')
+        .option('-a, --access <modifier>', 'Access modifier (public|private)', 'private')
+        .option('--default', 'Set as default pipeline', false)
+        .option('--active', 'Set pipeline as active', true)
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification')
+        .option('--dry-run', 'Validate inputs without creating pipeline', false)
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('Create Pipeline', 'Creating Pipeline');
+        const startTime = Date.now();
+        try {
+            // Display parameters
+            (0, output_utils_1.printInfo)('Configuration');
+            (0, output_utils_1.printKeyValue)({
+                'Project': options.project || '(from props file)',
+                'Organization': options.organization || '(from props file)',
+                'Name': options.name || '(not set)',
+                'Access Modifier': options.access,
+                'Default Pipeline': options.default ? 'Yes' : 'No',
+                'Active': options.active ? 'Yes' : 'No',
+                'Properties File': options.file,
+                'SSL Verification': options.verifySsl === false ? 'Disabled' : 'Enabled',
+                'Dry Run': options.dryRun ? 'Yes' : 'No',
+            });
+            // Security warning for SSL verification disabled
+            (0, command_utils_1.printSslWarning)(options.verifySsl);
+            console.log('');
+            (0, output_utils_1.printSection)('File Validation');
+            // Validate file exists
+            if (!fs.existsSync(options.file)) {
+                (0, output_utils_1.printError)('Properties file not found', { path: options.file });
+                throw new Error(`File not found: ${options.file}`);
+            }
+            // Check file extension
+            const fileExt = path.extname(options.file).toLowerCase();
+            if (fileExt !== '.json') {
+                (0, output_utils_1.printWarning)('File extension is not .json', { extension: fileExt });
+            }
+            const fileStats = fs.statSync(options.file);
+            // Check file size
+            if (fileStats.size > cli_constants_1.FILE_SIZE_LIMITS.PIPELINE_PROPS) {
+                (0, output_utils_1.printError)('Properties file is too large', {
+                    size: (0, cli_constants_1.formatFileSize)(fileStats.size),
+                    limit: (0, cli_constants_1.formatFileSize)(cli_constants_1.FILE_SIZE_LIMITS.PIPELINE_PROPS),
+                });
+                throw new Error('Properties file exceeds size limit');
+            }
+            (0, output_utils_1.printSuccess)('File validation passed');
+            (0, output_utils_1.printKeyValue)({
+                'File Path': options.file,
+                'File Size': (0, cli_constants_1.formatFileSize)(fileStats.size),
+                'Extension': fileExt,
+            });
+            // Read and parse properties file
+            console.log('');
+            (0, output_utils_1.printInfo)('Reading pipeline properties...');
+            const fileContent = fs.readFileSync(options.file, 'utf-8');
+            let props;
+            try {
+                props = JSON.parse(fileContent);
+            }
+            catch (error) {
+                (0, output_utils_1.printError)('Invalid JSON in properties file', {
+                    error: error instanceof Error ? error.message : String(error),
+                    hint: 'Ensure the file contains valid JSON syntax',
+                });
+                throw new Error('Properties file must contain valid JSON');
+            }
+            // Validate properties structure
+            if (typeof props !== 'object' || props === null) {
+                (0, output_utils_1.printError)('Invalid properties format', {
+                    type: typeof props,
+                    hint: 'Properties must be a JSON object',
+                });
+                throw new Error('Properties must be a valid object');
+            }
+            const propCount = Object.keys(props).length;
+            (0, output_utils_1.printSuccess)('Properties parsed successfully');
+            (0, output_utils_1.printKeyValue)({
+                'Total Keys': propCount.toString(),
+                'Sample Keys': Object.keys(props).slice(0, 5).join(', ') + (propCount > 5 ? '...' : ''),
+            });
+            // Validate properties content
+            if (propCount === 0) {
+                (0, output_utils_1.printWarning)('Properties object is empty - pipeline will have no configuration');
+            }
+            // Resolve project & organization: prefer CLI flags, fall back to
+            // values embedded inside the props file (builderProps).
+            const resolvedProject = options.project ?? props.project;
+            const resolvedOrganization = options.organization ?? props.organization;
+            if (!resolvedProject) {
+                (0, output_utils_1.printError)('Project is required', {
+                    hint: 'Provide -p/--project flag or include "project" in the props file',
+                });
+                throw new Error('Project is required');
+            }
+            if (!resolvedOrganization) {
+                (0, output_utils_1.printError)('Organization is required', {
+                    hint: 'Provide -o/--organization flag or include "organization" in the props file',
+                });
+                throw new Error('Organization is required');
+            }
+            // Build request payload — resolve pipelineName using same strategy as pipeline-builder.ts:
+            //   props.pipelineName ?? `${organization}-${project}-pipeline`
+            const sanitize = (s) => s.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+            const resolvedPipelineName = options.name
+                ?? props.pipelineName
+                ?? `${sanitize(resolvedOrganization)}-${sanitize(resolvedProject)}-pipeline`;
+            const payload = {
+                project: resolvedProject,
+                organization: resolvedOrganization,
+                pipelineName: resolvedPipelineName,
+                props,
+            };
+            // Add optional fields only if provided
+            if (options.access) {
+                payload.accessModifier = options.access;
+            }
+            if (options.default !== undefined) {
+                payload.isDefault = options.default;
+            }
+            if (options.active !== undefined) {
+                payload.isActive = options.active;
+            }
+            // Dry run mode
+            if (options.dryRun) {
+                console.log('');
+                (0, output_utils_1.printSection)('Dry Run - Request Preview');
+                console.log(JSON.stringify(payload, null, 2));
+                console.log('');
+                (0, output_utils_1.printSuccess)('✓ Validation complete - no pipeline created (dry run mode)');
+                console.log('');
+                (0, output_utils_1.printInfo)('To create the pipeline, run the command without --dry-run');
+                return;
+            }
+            // Create authenticated API client
+            const client = (0, command_utils_1.createAuthenticatedClient)(options);
+            const config = client.getConfig();
+            // Create pipeline
+            console.log('');
+            (0, output_utils_1.printSection)('Creating Pipeline');
+            const spinner = (0, ora_1.default)('Creating pipeline...').start();
+            let rawResponse;
+            let requestDuration;
+            try {
+                const requestStart = Date.now();
+                rawResponse = await client.post(config.api.pipelineUrl, payload);
+                requestDuration = Date.now() - requestStart;
+                spinner.succeed('Pipeline created');
+            }
+            catch (error) {
+                spinner.fail('Pipeline creation failed');
+                throw error;
+            }
+            const pipeline = (0, output_utils_1.extractSingleResponse)(rawResponse, 'pipeline', 'id');
+            if (!pipeline?.id) {
+                (0, output_utils_1.printError)('Invalid pipeline response', {
+                    responseKeys: rawResponse ? Object.keys(rawResponse) : '(null)',
+                });
+                throw new Error('Pipeline creation failed - no valid pipeline data received');
+            }
+            console.log('');
+            (0, output_utils_1.printSection)('✓ Pipeline Created Successfully');
+            // Display created pipeline info
+            (0, output_utils_1.printKeyValue)({
+                'Pipeline ID': green(bold(pipeline.id)),
+                'Project': pipeline.project,
+                'Organization': pipeline.organization,
+                'Name': pipeline.pipelineName || '(not set)',
+                'Access': pipeline.accessModifier || 'private',
+                'Default': pipeline.isDefault ? 'Yes' : 'No',
+                'Active': pipeline.isActive ? 'Yes' : 'No',
+                'Properties': pipeline.props ? `${Object.keys(pipeline.props).length} keys` : '(not returned)',
+            });
+            if (pipeline.createdAt) {
+                console.log('');
+                (0, output_utils_1.printKeyValue)({
+                    'Created At': pipeline.createdAt,
+                });
+            }
+            // Performance metrics
+            console.log('');
+            (0, output_utils_1.printKeyValue)({
+                'Execution ID': executionId,
+                'Request Duration': (0, cli_constants_1.formatDuration)(requestDuration),
+                'Total Duration': (0, cli_constants_1.formatDuration)(Date.now() - startTime),
+            });
+            // Save pipeline info to file
+            const outputDir = './output';
+            (0, output_utils_1.ensureOutputDirectory)(outputDir);
+            const outputFile = path.join(outputDir, `pipeline-${pipeline.id}.json`);
+            fs.writeFileSync(outputFile, JSON.stringify(pipeline, null, 2));
+            console.log('');
+            (0, output_utils_1.printSuccess)('Pipeline details saved to file');
+            (0, output_utils_1.printKeyValue)({
+                'Output File': outputFile,
+                'File Size': (0, cli_constants_1.formatFileSize)(fs.statSync(outputFile).size),
+            });
+            // Next steps
+            console.log('');
+            (0, output_utils_1.printSection)('Next Steps');
+            console.log(dim('You can now:'));
+            console.log(`  ${cyan('•')} Deploy: ${bold(`deploy --id ${pipeline.id}`)}`);
+            console.log(`  ${cyan('•')} View: ${bold(`get-pipeline --id ${pipeline.id}`)}`);
+            console.log(`  ${cyan('•')} API: ${config.api.baseUrl}${config.api.pipelineUrl}/${pipeline.id}`);
+            console.log('');
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'create-pipeline',
+                    executionId,
+                    project: options.project,
+                    organization: options.organization,
+                    file: options.file,
+                    verifySsl: options.verifySsl,
+                    dryRun: options.dryRun,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-pipeline.js","sourceRoot":"","sources":["../../src/commands/create-pipeline.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 ora from 'ora';\nimport pico from 'picocolors';\nimport { formatDuration, formatFileSize, FILE_SIZE_LIMITS } from '../config/cli.constants';\nimport { Pipeline, PipelineResponse, CreatePipelineRequest } from '../types';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClient } from '../utils/command-utils';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { ensureOutputDirectory, extractSingleResponse, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils';\n\nconst { bold, cyan, dim, green } = pico;\n\n/**\n * Registers the `create-pipeline` command with the CLI program.\n *\n * Accepts a pipeline properties JSON file, validates it, resolves\n * project/organization from CLI flags or the props file, and\n * creates the pipeline via the platform API.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function createPipeline(program: Command): void {\n  program\n    .command('create-pipeline')\n    .description('Create a new pipeline with the provided configuration')\n    .requiredOption('-f, --file <file>', 'Path to pipeline properties JSON file')\n    .option('-p, --project <project>', 'Project name (falls back to value in props file)')\n    .option('-o, --organization <organization>', 'Organization name (falls back to value in props file)')\n    .option('-n, --name <name>', 'Pipeline name')\n    .option('-a, --access <modifier>', 'Access modifier (public|private)', 'private')\n    .option('--default', 'Set as default pipeline', false)\n    .option('--active', 'Set pipeline 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 inputs without creating pipeline', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Create Pipeline', 'Creating Pipeline');\n      const startTime = Date.now();\n\n      try {\n\n        // Display parameters\n        printInfo('Configuration');\n        printKeyValue({\n          'Project': options.project || '(from props file)',\n          'Organization': options.organization || '(from props file)',\n          'Name': options.name || '(not set)',\n          'Access Modifier': options.access,\n          'Default Pipeline': options.default ? 'Yes' : 'No',\n          'Active': options.active ? 'Yes' : 'No',\n          'Properties File': options.file,\n          'SSL Verification': options.verifySsl === false ? 'Disabled' : 'Enabled',\n          'Dry Run': options.dryRun ? 'Yes' : 'No',\n        });\n\n        // Security warning for SSL verification disabled\n        printSslWarning(options.verifySsl);\n\n        console.log('');\n        printSection('File Validation');\n\n        // Validate file exists\n        if (!fs.existsSync(options.file)) {\n          printError('Properties file not found', { path: options.file });\n          throw new Error(`File not found: ${options.file}`);\n        }\n\n        // Check file extension\n        const fileExt = path.extname(options.file).toLowerCase();\n        if (fileExt !== '.json') {\n          printWarning('File extension is not .json', { extension: fileExt });\n        }\n\n        const fileStats = fs.statSync(options.file);\n\n        // Check file size\n        if (fileStats.size > FILE_SIZE_LIMITS.PIPELINE_PROPS) {\n          printError('Properties file is too large', {\n            size: formatFileSize(fileStats.size),\n            limit: formatFileSize(FILE_SIZE_LIMITS.PIPELINE_PROPS),\n          });\n          throw new Error('Properties file exceeds size limit');\n        }\n\n        printSuccess('File validation passed');\n        printKeyValue({\n          'File Path': options.file,\n          'File Size': formatFileSize(fileStats.size),\n          'Extension': fileExt,\n        });\n\n        // Read and parse properties file\n        console.log('');\n        printInfo('Reading pipeline properties...');\n\n        const fileContent = fs.readFileSync(options.file, 'utf-8');\n\n        let props: Record<string, unknown>;\n        try {\n          props = JSON.parse(fileContent);\n        } catch (error) {\n          printError('Invalid JSON in properties file', {\n            error: error instanceof Error ? error.message : String(error),\n            hint: 'Ensure the file contains valid JSON syntax',\n          });\n          throw new Error('Properties file must contain valid JSON');\n        }\n\n        // Validate properties structure\n        if (typeof props !== 'object' || props === null) {\n          printError('Invalid properties format', {\n            type: typeof props,\n            hint: 'Properties must be a JSON object',\n          });\n          throw new Error('Properties must be a valid object');\n        }\n\n        const propCount = Object.keys(props).length;\n\n        printSuccess('Properties parsed successfully');\n        printKeyValue({\n          'Total Keys': propCount.toString(),\n          'Sample Keys': Object.keys(props).slice(0, 5).join(', ') + (propCount > 5 ? '...' : ''),\n        });\n\n        // Validate properties content\n        if (propCount === 0) {\n          printWarning('Properties object is empty - pipeline will have no configuration');\n        }\n\n        // Resolve project & organization: prefer CLI flags, fall back to\n        // values embedded inside the props file (builderProps).\n        const resolvedProject = options.project ?? (props.project as string | undefined);\n        const resolvedOrganization = options.organization ?? (props.organization as string | undefined);\n\n        if (!resolvedProject) {\n          printError('Project is required', {\n            hint: 'Provide -p/--project flag or include \"project\" in the props file',\n          });\n          throw new Error('Project is required');\n        }\n        if (!resolvedOrganization) {\n          printError('Organization is required', {\n            hint: 'Provide -o/--organization flag or include \"organization\" in the props file',\n          });\n          throw new Error('Organization is required');\n        }\n\n        // Build request payload — resolve pipelineName using same strategy as pipeline-builder.ts:\n        //   props.pipelineName ?? `${organization}-${project}-pipeline`\n        const sanitize = (s: string) => s.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();\n        const resolvedPipelineName = options.name\n          ?? (props.pipelineName as string | undefined)\n          ?? `${sanitize(resolvedOrganization)}-${sanitize(resolvedProject)}-pipeline`;\n\n        const payload: CreatePipelineRequest = {\n          project: resolvedProject,\n          organization: resolvedOrganization,\n          pipelineName: resolvedPipelineName,\n          props,\n        };\n\n        // Add optional fields only if provided\n        if (options.access) {\n          payload.accessModifier = options.access;\n        }\n        if (options.default !== undefined) {\n          payload.isDefault = options.default;\n        }\n        if (options.active !== undefined) {\n          payload.isActive = options.active;\n        }\n\n        // Dry run mode\n        if (options.dryRun) {\n          console.log('');\n          printSection('Dry Run - Request Preview');\n          console.log(JSON.stringify(payload, null, 2));\n          console.log('');\n          printSuccess('✓ Validation complete - no pipeline created (dry run mode)');\n          console.log('');\n          printInfo('To create the pipeline, run the command without --dry-run');\n          return;\n        }\n\n        // Create authenticated API client\n        const client = createAuthenticatedClient(options);\n        const config = client.getConfig();\n\n        // Create pipeline\n        console.log('');\n        printSection('Creating Pipeline');\n\n        const spinner = ora('Creating pipeline...').start();\n        let rawResponse: PipelineResponse;\n        let requestDuration: number;\n        try {\n          const requestStart = Date.now();\n          rawResponse = await client.post<PipelineResponse>(\n            config.api.pipelineUrl,\n            payload,\n          );\n          requestDuration = Date.now() - requestStart;\n          spinner.succeed('Pipeline created');\n        } catch (error) {\n          spinner.fail('Pipeline creation failed');\n          throw error;\n        }\n\n        const pipeline = extractSingleResponse<Pipeline>(rawResponse, 'pipeline', 'id');\n\n        if (!pipeline?.id) {\n          printError('Invalid pipeline response', {\n            responseKeys: rawResponse ? Object.keys(rawResponse) : '(null)',\n          });\n          throw new Error('Pipeline creation failed - no valid pipeline data received');\n        }\n\n        console.log('');\n        printSection('✓ Pipeline Created Successfully');\n\n        // Display created pipeline info\n        printKeyValue({\n          'Pipeline ID': green(bold(pipeline.id)),\n          'Project': pipeline.project,\n          'Organization': pipeline.organization,\n          'Name': pipeline.pipelineName || '(not set)',\n          'Access': pipeline.accessModifier || 'private',\n          'Default': pipeline.isDefault ? 'Yes' : 'No',\n          'Active': pipeline.isActive ? 'Yes' : 'No',\n          'Properties': pipeline.props ? `${Object.keys(pipeline.props).length} keys` : '(not returned)',\n        });\n\n        if (pipeline.createdAt) {\n          console.log('');\n          printKeyValue({\n            'Created At': pipeline.createdAt,\n          });\n        }\n\n        // Performance metrics\n        console.log('');\n        printKeyValue({\n          'Execution ID': executionId,\n          'Request Duration': formatDuration(requestDuration),\n          'Total Duration': formatDuration(Date.now() - startTime),\n        });\n\n        // Save pipeline info to file\n        const outputDir = './output';\n        ensureOutputDirectory(outputDir);\n\n        const outputFile = path.join(outputDir, `pipeline-${pipeline.id}.json`);\n        fs.writeFileSync(outputFile, JSON.stringify(pipeline, null, 2));\n\n        console.log('');\n        printSuccess('Pipeline details saved to file');\n        printKeyValue({\n          'Output File': outputFile,\n          'File Size': formatFileSize(fs.statSync(outputFile).size),\n        });\n\n        // Next steps\n        console.log('');\n        printSection('Next Steps');\n        console.log(dim('You can now:'));\n        console.log(`  ${cyan('•')} Deploy: ${bold(`deploy --id ${pipeline.id}`)}`);\n        console.log(`  ${cyan('•')} View: ${bold(`get-pipeline --id ${pipeline.id}`)}`);\n        console.log(`  ${cyan('•')} API: ${config.api.baseUrl}${config.api.pipelineUrl}/${pipeline.id}`);\n        console.log('');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'create-pipeline',\n            executionId,\n            project: options.project,\n            organization: options.organization,\n            file: options.file,\n            verifySsl: options.verifySsl,\n            dryRun: options.dryRun,\n          },\n        });\n      }\n    });\n}"]}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+/**
+ * Registers the `deploy` command with the CLI program.
+ *
+ * Fetches pipeline properties by ID from the platform API, then
+ * runs `cdk deploy` to provision the pipeline infrastructure in AWS.
+ * For synthesis only, use `pipeline-manager synth`.
+ *
+ * Requires service credentials to be pre-stored in AWS Secrets Manager.
+ * Create them first with: `pipeline-manager store-token`
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function deploy(program: Command): void;
+//# sourceMappingURL=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiK7C"}