@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/create-pipeline.js

@@ -0,0 +1,315 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import ora from 'ora';
+import pico from 'picocolors';
+import { formatDuration, formatFileSize, FILE_SIZE_LIMITS, defaultPipelineName } from '../config/cli.constants.js';
+import {} from '../types/index.js';
+import { printCommandHeader, printSslWarning, createAuthenticatedClient, createAuthenticatedClientAsync, withSslOptions, withProfileOption, withRegionOption } from '../utils/command-utils.js';
+import { runDeploy } from '../utils/deploy-runner.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { ensureOutputDirectory, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { fetchPipelineProps } from '../utils/pipeline-config.js';
+import { extractSingleResponse } from '../utils/response-utils.js';
+import { relaxTlsForCli } from '../utils/tls.js';
+const { bold, cyan, dim, green } = pico;
+/**
+ * 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 function createPipeline(program) {
+    withSslOptions(withRegionOption(withProfileOption(program
+        .command('create')
+        .description('Create a new pipeline — and optionally deploy it with --deploy')
+        .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, --visibility <rung>', 'Sharing rung (private|org|public). Pipelines default to org — a team asset is visible to the team.', 'org')
+        .option('--default', 'Set as default pipeline', false)
+        .option('--active', 'Set pipeline as active', true)
+        .option('--no-active', 'Create the pipeline as inactive')
+        // --deploy: after creating the record, run the same CDK deploy + ARN
+        // registration as `pipeline deploy --id` (shared runDeploy). The flags
+        // below apply only with --deploy.
+        .option('--deploy', 'Deploy the pipeline with AWS CDK immediately after creating it', false)
+        .option('--require-approval <approval>', 'Deploy approval level: never|any-change|broadening (with --deploy)', 'never')
+        .option('--output <dir>', 'CDK output directory (with --deploy)', 'cdk.out')
+        .option('--store-tokens', 'Deploy auth via AWS Secrets Manager token (with --deploy; requires PLATFORM_SECRET_NAME)', false))))
+        .option('--dry-run', 'Validate inputs without creating pipeline', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Create Pipeline', 'Creating Pipeline');
+        const startTime = Date.now();
+        try {
+            // Display parameters
+            printInfo('Configuration');
+            printKeyValue({
+                'Project': options.project || '(from props file)',
+                'Organization': options.organization || '(from props file)',
+                'Name': options.name || '(not set)',
+                'Visibility': options.visibility,
+                'Default Pipeline': options.default ? 'Yes' : 'No',
+                'Active': options.active ? 'Yes' : 'No',
+                'Deploy After Create': options.deploy ? `Yes (profile: ${options.profile || 'default'})` : 'No',
+                'Properties File': options.file,
+                'SSL Verification': options.verifySsl === false ? 'Disabled' : 'Enabled',
+                'Dry Run': options.dryRun ? 'Yes' : 'No',
+            });
+            // Security warning for SSL verification disabled
+            printSslWarning(options.verifySsl);
+            console.log('');
+            printSection('File Validation');
+            // Validate file exists
+            if (!fs.existsSync(options.file)) {
+                printError('Properties file not found', { path: options.file });
+                throw new ValidationError(`File not found: ${options.file}`, 'file');
+            }
+            // Check file extension
+            const fileExt = path.extname(options.file).toLowerCase();
+            if (fileExt !== '.json') {
+                printWarning('File extension is not .json', { extension: fileExt });
+            }
+            const fileStats = fs.statSync(options.file);
+            // Check file size
+            if (fileStats.size > FILE_SIZE_LIMITS.PIPELINE_PROPS) {
+                printError('Properties file is too large', {
+                    size: formatFileSize(fileStats.size),
+                    limit: formatFileSize(FILE_SIZE_LIMITS.PIPELINE_PROPS),
+                });
+                throw new ValidationError('Properties file exceeds size limit', 'file');
+            }
+            printSuccess('File validation passed');
+            printKeyValue({
+                'File Path': options.file,
+                'File Size': formatFileSize(fileStats.size),
+                'Extension': fileExt,
+            });
+            // Read and parse properties file
+            console.log('');
+            printInfo('Reading pipeline properties...');
+            const fileContent = fs.readFileSync(options.file, 'utf-8');
+            let props;
+            try {
+                props = JSON.parse(fileContent);
+            }
+            catch (error) {
+                printError('Invalid JSON in properties file', {
+                    error: error instanceof Error ? error.message : String(error),
+                    hint: 'Ensure the file contains valid JSON syntax',
+                });
+                throw new ValidationError('Properties file must contain valid JSON', 'file');
+            }
+            // Validate properties structure
+            if (typeof props !== 'object' || props === null) {
+                printError('Invalid properties format', {
+                    type: typeof props,
+                    hint: 'Properties must be a JSON object',
+                });
+                throw new ValidationError('Properties must be a valid object', 'file');
+            }
+            const propCount = Object.keys(props).length;
+            printSuccess('Properties parsed successfully');
+            printKeyValue({
+                'Total Keys': propCount.toString(),
+                'Sample Keys': Object.keys(props).slice(0, 5).join(', ') + (propCount > 5 ? '...' : ''),
+            });
+            // Validate properties content
+            if (propCount === 0) {
+                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) {
+                printError('Project is required', {
+                    hint: 'Provide -p/--project flag or include "project" in the props file',
+                });
+                throw new ValidationError('Project is required', 'project');
+            }
+            if (!resolvedOrganization) {
+                printError('Organization is required', {
+                    hint: 'Provide -o/--organization flag or include "organization" in the props file',
+                });
+                throw new ValidationError('Organization is required', 'organization');
+            }
+            // Resolve pipelineName with the shared default (mirrors pipeline-core's
+            // pipeline-configuration.ts) so create + registry + CDK all agree.
+            const resolvedPipelineName = options.name
+                ?? props.pipelineName
+                ?? defaultPipelineName(resolvedOrganization, resolvedProject);
+            const payload = {
+                project: resolvedProject,
+                organization: resolvedOrganization,
+                pipelineName: resolvedPipelineName,
+                props,
+            };
+            // Add optional fields only if provided
+            if (options.visibility) {
+                payload.visibility = options.visibility;
+            }
+            if (options.default !== undefined) {
+                payload.isDefault = options.default;
+            }
+            if (options.active !== undefined) {
+                payload.isActive = options.active;
+            }
+            // Dry run mode
+            if (options.dryRun) {
+                console.log('');
+                printSection('Dry Run - Request Preview');
+                console.log(JSON.stringify(payload, null, 2));
+                console.log('');
+                printSuccess('✓ Validation complete - no pipeline created (dry run mode)');
+                console.log('');
+                if (options.deploy) {
+                    printInfo('With --deploy, the pipeline would be deployed via CDK after creation', {
+                        profile: options.profile || '(default)',
+                        region: options.region || '(default)',
+                        requireApproval: options.requireApproval,
+                    });
+                }
+                printInfo('To create the pipeline, run the command without --dry-run');
+                return;
+            }
+            // Create authenticated API client
+            const client = createAuthenticatedClient(options);
+            const config = client.getConfig();
+            // Create pipeline
+            console.log('');
+            printSection('Creating Pipeline');
+            const spinner = ora('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 = extractSingleResponse(rawResponse, 'pipeline', 'id');
+            if (!pipeline?.id) {
+                printError('Invalid pipeline response', {
+                    responseKeys: rawResponse ? Object.keys(rawResponse) : '(null)',
+                });
+                throw new Error('Pipeline creation failed - no valid pipeline data received');
+            }
+            console.log('');
+            printSection('✓ Pipeline Created Successfully');
+            // Display created pipeline info
+            printKeyValue({
+                'Pipeline ID': green(bold(pipeline.id)),
+                'Project': pipeline.project,
+                'Organization': pipeline.organization,
+                'Name': pipeline.pipelineName || '(not set)',
+                'Visibility': pipeline.visibility || 'org',
+                '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('');
+                printKeyValue({
+                    'Created At': pipeline.createdAt,
+                });
+            }
+            // Performance metrics
+            console.log('');
+            printKeyValue({
+                'Execution ID': executionId,
+                'Request Duration': formatDuration(requestDuration),
+                'Total Duration': formatDuration(Date.now() - startTime),
+            });
+            // Save pipeline info to file
+            const outputDir = './output';
+            ensureOutputDirectory(outputDir);
+            const outputFile = path.join(outputDir, `pipeline-${pipeline.id}.json`);
+            fs.writeFileSync(outputFile, JSON.stringify(pipeline, null, 2));
+            console.log('');
+            printSuccess('Pipeline details saved to file');
+            printKeyValue({
+                'Output File': outputFile,
+                'File Size': formatFileSize(fs.statSync(outputFile).size),
+            });
+            // ── Optional deploy (--deploy) ──
+            // The record now exists and is authoritative. If the deploy fails we KEEP
+            // it and surface the exact retry rather than rolling back (never false-green).
+            if (options.deploy) {
+                console.log('');
+                printSection('Deploying Pipeline');
+                try {
+                    // Deploy touches the AWS SDK + the CDK synth subprocess; relax TLS the
+                    // same way `deploy` does (refused in production by relaxTlsForCli).
+                    relaxTlsForCli(options.verifySsl, printWarning);
+                    // The async client adds --store-tokens (Secrets Manager) support and
+                    // backs BOTH the props fetch and the registry callback.
+                    const deployClient = await createAuthenticatedClientAsync(options);
+                    const deployConfig = deployClient.getConfig();
+                    // Re-fetch the just-created pipeline so plugins are resolved and the
+                    // registry host is baked EXACTLY as `deploy --id` does — no drift.
+                    const fetched = await fetchPipelineProps(deployClient, pipeline.id);
+                    await runDeploy({
+                        pipeline: fetched.pipeline,
+                        propsWithIds: fetched.propsWithIds,
+                        profile: options.profile,
+                        region: options.region,
+                        requireApproval: options.requireApproval,
+                        output: options.output,
+                        debug: program.opts().debug,
+                        executionId,
+                        platformClient: deployClient,
+                        platformPipelineUrl: deployConfig.api.pipelineUrl,
+                        platformBaseUrl: deployConfig.api.baseUrl,
+                    });
+                }
+                catch (deployError) {
+                    printError('Pipeline was created but the deploy failed', {
+                        pipelineId: pipeline.id,
+                        error: deployError instanceof Error ? deployError.message : String(deployError),
+                        retry: `pipeline-manager pipeline deploy --id ${pipeline.id}`,
+                    });
+                    // Re-throw so the process exits non-zero. The record is intentionally
+                    // retained — re-run the deploy with the command above.
+                    throw deployError;
+                }
+            }
+            // Next steps
+            console.log('');
+            printSection('Next Steps');
+            console.log(dim('You can now:'));
+            if (!options.deploy) {
+                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) {
+            handleError(error, 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, defaultPipelineName } from '../config/cli.constants.js';\nimport { type Pipeline, type PipelineResponse, type CreatePipelineRequest, type PlatformDeployConfig } from '../types/index.js';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClient, createAuthenticatedClientAsync, withSslOptions, withProfileOption, withRegionOption } from '../utils/command-utils.js';\nimport { runDeploy } from '../utils/deploy-runner.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { ensureOutputDirectory, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { fetchPipelineProps } from '../utils/pipeline-config.js';\nimport { extractSingleResponse } from '../utils/response-utils.js';\nimport { relaxTlsForCli } from '../utils/tls.js';\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  withSslOptions(\n    withRegionOption(\n      withProfileOption(program\n        .command('create')\n        .description('Create a new pipeline — and optionally deploy it with --deploy')\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, --visibility <rung>', 'Sharing rung (private|org|public). Pipelines default to org — a team asset is visible to the team.', 'org')\n        .option('--default', 'Set as default pipeline', false)\n        .option('--active', 'Set pipeline as active', true)\n        .option('--no-active', 'Create the pipeline as inactive')\n        // --deploy: after creating the record, run the same CDK deploy + ARN\n        // registration as `pipeline deploy --id` (shared runDeploy). The flags\n        // below apply only with --deploy.\n        .option('--deploy', 'Deploy the pipeline with AWS CDK immediately after creating it', false)\n        .option('--require-approval <approval>', 'Deploy approval level: never|any-change|broadening (with --deploy)', 'never')\n        .option('--output <dir>', 'CDK output directory (with --deploy)', 'cdk.out')\n        .option('--store-tokens', 'Deploy auth via AWS Secrets Manager token (with --deploy; requires PLATFORM_SECRET_NAME)', false)),\n    ),\n  )\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          'Visibility': options.visibility,\n          'Default Pipeline': options.default ? 'Yes' : 'No',\n          'Active': options.active ? 'Yes' : 'No',\n          'Deploy After Create': options.deploy ? `Yes (profile: ${options.profile || 'default'})` : '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 ValidationError(`File not found: ${options.file}`, '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 ValidationError('Properties file exceeds size limit', 'file');\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 ValidationError('Properties file must contain valid JSON', 'file');\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 ValidationError('Properties must be a valid object', 'file');\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 ValidationError('Project is required', 'project');\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 ValidationError('Organization is required', 'organization');\n        }\n\n        // Resolve pipelineName with the shared default (mirrors pipeline-core's\n        // pipeline-configuration.ts) so create + registry + CDK all agree.\n        const resolvedPipelineName = options.name\n          ?? (props.pipelineName as string | undefined)\n          ?? defaultPipelineName(resolvedOrganization, resolvedProject);\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.visibility) {\n          payload.visibility = options.visibility;\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          if (options.deploy) {\n            printInfo('With --deploy, the pipeline would be deployed via CDK after creation', {\n              profile: options.profile || '(default)',\n              region: options.region || '(default)',\n              requireApproval: options.requireApproval,\n            });\n          }\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          'Visibility': pipeline.visibility || 'org',\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        // ── Optional deploy (--deploy) ──\n        // The record now exists and is authoritative. If the deploy fails we KEEP\n        // it and surface the exact retry rather than rolling back (never false-green).\n        if (options.deploy) {\n          console.log('');\n          printSection('Deploying Pipeline');\n          try {\n            // Deploy touches the AWS SDK + the CDK synth subprocess; relax TLS the\n            // same way `deploy` does (refused in production by relaxTlsForCli).\n            relaxTlsForCli(options.verifySsl, printWarning);\n            // The async client adds --store-tokens (Secrets Manager) support and\n            // backs BOTH the props fetch and the registry callback.\n            const deployClient = await createAuthenticatedClientAsync(options);\n            const deployConfig = deployClient.getConfig() as PlatformDeployConfig;\n            // Re-fetch the just-created pipeline so plugins are resolved and the\n            // registry host is baked EXACTLY as `deploy --id` does — no drift.\n            const fetched = await fetchPipelineProps(deployClient, pipeline.id);\n            await runDeploy({\n              pipeline: fetched.pipeline,\n              propsWithIds: fetched.propsWithIds,\n              profile: options.profile,\n              region: options.region,\n              requireApproval: options.requireApproval,\n              output: options.output,\n              debug: program.opts().debug,\n              executionId,\n              platformClient: deployClient,\n              platformPipelineUrl: deployConfig.api.pipelineUrl,\n              platformBaseUrl: deployConfig.api.baseUrl,\n            });\n          } catch (deployError) {\n            printError('Pipeline was created but the deploy failed', {\n              pipelineId: pipeline.id,\n              error: deployError instanceof Error ? deployError.message : String(deployError),\n              retry: `pipeline-manager pipeline deploy --id ${pipeline.id}`,\n            });\n            // Re-throw so the process exits non-zero. The record is intentionally\n            // retained — re-run the deploy with the command above.\n            throw deployError;\n          }\n        }\n\n        // Next steps\n        console.log('');\n        printSection('Next Steps');\n        console.log(dim('You can now:'));\n        if (!options.deploy) {\n          console.log(`  ${cyan('•')} Deploy: ${bold(`deploy --id ${pipeline.id}`)}`);\n        }\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 pipeline synth`.
+ *
+ * Requires service credentials to be pre-stored in AWS Secrets Manager.
+ * Create them first with: `pipeline-manager infra 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;AAUpC;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiJ7C"}

package/dist/commands/deploy.js

@@ -0,0 +1,157 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Command } from 'commander';
+import {} from '../types/index.js';
+import { auditLog } from '../utils/audit-log.js';
+import { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';
+import { runDeploy } from '../utils/deploy-runner.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printInfo, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';
+import { fetchPipelineProps, printResolvedOrExit } from '../utils/pipeline-config.js';
+import { relaxTlsForCli } from '../utils/tls.js';
+/**
+ * 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 pipeline synth`.
+ *
+ * Requires service credentials to be pre-stored in AWS Secrets Manager.
+ * Create them first with: `pipeline-manager infra store-token`
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export function deploy(program) {
+    withSslOptions(withRegionOption(withProfileOption(program
+        .command('deploy')
+        .description('Deploy pipeline by ID using AWS CDK, or --local-spec to deploy a local pipeline.json without the platform')
+        .option('-i, --id <id>', 'Pipeline ID (fetches config from the platform)')
+        .option('--local-spec <path>', 'Path to a local pipeline.json — deploys without contacting the platform (no auth, no compliance, no plugin lookup)'))
+        .option('--require-approval <approval>', 'Approval level: never|any-change|broadening', 'never')
+        .option('--output <dir>', 'CDK output directory', 'cdk.out')
+        .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)))
+        .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without deploying', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Pipeline Deploy');
+        try {
+            // Mutually exclusive input sources — validated INSIDE the try so failures route
+            // through handleError (consistent exit code/format) like every other command.
+            if (!options.id && !options.localSpec) {
+                throw new Error('Either --id <pipeline-id> or --local-spec <path> is required');
+            }
+            if (options.id && options.localSpec) {
+                throw new Error('--id and --local-spec are mutually exclusive');
+            }
+            auditLog('deploy', { executionId, pipelineId: options.id, profile: options.profile });
+            printInfo('Deployment parameters', {
+                id: options.id,
+                awsProfile: options.profile,
+                outputDir: options.output,
+                requireApproval: options.requireApproval,
+                verifySsl: options.verifySsl,
+            });
+            // Security warning for SSL verification disabled
+            printSslWarning(options.verifySsl);
+            // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it,
+            // but refuse in production (see relaxTlsForCli) — the flag disables cert
+            // validation for ALL outbound TLS, including the AWS SDK.
+            relaxTlsForCli(options.verifySsl, printWarning);
+            // Local-tool prerequisites (cdk + esbuild/pnpm) are verified up front by
+            // the CLI's preAction hook, so by here they're guaranteed present.
+            let pipeline;
+            let propsWithIds;
+            // Remote-mode registry-post handles — null in --local-spec mode.
+            let platformClient;
+            let platformConfig;
+            if (options.localSpec) {
+                // --local-spec: read pipeline.json from disk; no platform contact.
+                // Compliance / quota / plugin-lookup features all require the platform —
+                // this mode is for air-gapped or simple standalone CDK deployments.
+                const absPath = path.resolve(options.localSpec);
+                printInfo('Loading local pipeline spec', { path: absPath });
+                if (!fs.existsSync(absPath)) {
+                    throw new Error(`Local spec file not found: ${absPath}`);
+                }
+                const raw = fs.readFileSync(absPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (!parsed.props) {
+                    throw new Error(`Local spec file is missing required 'props' field: ${absPath}`);
+                }
+                pipeline = {
+                    id: parsed.id ?? 'local',
+                    project: parsed.project ?? 'local-project',
+                    organization: parsed.organization ?? 'local-org',
+                    orgId: parsed.orgId,
+                    isDefault: parsed.isDefault ?? false,
+                    isActive: parsed.isActive ?? true,
+                    props: parsed.props,
+                };
+                printSuccess('Local spec loaded');
+                printKeyValue({
+                    Source: absPath,
+                    Project: pipeline.project,
+                    Organization: pipeline.organization,
+                });
+                propsWithIds = {
+                    ...pipeline.props,
+                    ...(pipeline.orgId && { orgId: pipeline.orgId }),
+                    pipelineId: pipeline.id,
+                };
+            }
+            else {
+                // Remote path: fetch config from platform API. fetchPipelineProps does
+                // the fetch + plugin pre-resolution + registry pull-host bake — shared
+                // verbatim with `synth` so the two never drift.
+                platformClient = await createAuthenticatedClientAsync(options);
+                platformConfig = platformClient.getConfig();
+                printInfo('Fetching pipeline configuration', { id: options.id });
+                const fetched = await fetchPipelineProps(platformClient, options.id);
+                pipeline = fetched.pipeline;
+                propsWithIds = fetched.propsWithIds;
+                printSuccess('Pipeline configuration retrieved');
+                printKeyValue({
+                    'ID': pipeline.id,
+                    'Project': pipeline.project,
+                    'Organization': pipeline.organization,
+                    'Is Default': pipeline.isDefault,
+                    'Is Active': pipeline.isActive,
+                });
+            }
+            // --show-resolved: print resolved config and exit (no CDK deploy)
+            if (options.showResolved) {
+                await printResolvedOrExit(propsWithIds);
+                return;
+            }
+            // Steps 5–9 (encode props → cdk deploy → register ARN) are shared with
+            // `pipeline create --deploy` via runDeploy so the two never drift.
+            await runDeploy({
+                pipeline,
+                propsWithIds,
+                profile: options.profile,
+                region: options.region,
+                requireApproval: options.requireApproval,
+                output: options.output,
+                debug: program.opts().debug,
+                executionId,
+                platformClient,
+                platformPipelineUrl: platformConfig?.api.pipelineUrl,
+                platformBaseUrl: platformConfig?.api.baseUrl,
+            });
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'deploy',
+                    executionId,
+                    pipelineId: options.id,
+                    verifySsl: options.verifySsl,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy.js","sourceRoot":"","sources":["../../src/commands/deploy.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 'node:fs';\nimport * as path from 'node:path';\nimport { Command } from 'commander';\nimport { type Pipeline, type PlatformDeployConfig } from '../types/index.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { runDeploy } from '../utils/deploy-runner.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printInfo, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { fetchPipelineProps, printResolvedOrExit } from '../utils/pipeline-config.js';\nimport { relaxTlsForCli } from '../utils/tls.js';\n\n/**\n * Registers the `deploy` command with the CLI program.\n *\n * Fetches pipeline properties by ID from the platform API, then\n * runs `cdk deploy` to provision the pipeline infrastructure in AWS.\n * For synthesis only, use `pipeline-manager pipeline synth`.\n *\n * Requires service credentials to be pre-stored in AWS Secrets Manager.\n * Create them first with: `pipeline-manager infra store-token`\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function deploy(program: Command): void {\n  withSslOptions(\n    withRegionOption(\n      withProfileOption(program\n        .command('deploy')\n        .description('Deploy pipeline by ID using AWS CDK, or --local-spec to deploy a local pipeline.json without the platform')\n        .option('-i, --id <id>', 'Pipeline ID (fetches config from the platform)')\n        .option('--local-spec <path>', 'Path to a local pipeline.json — deploys without contacting the platform (no auth, no compliance, no plugin lookup)'))\n        .option('--require-approval <approval>', 'Approval level: never|any-change|broadening', 'never')\n        .option('--output <dir>', 'CDK output directory', 'cdk.out')\n        .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false),\n    ),\n  )\n    .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without deploying', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Pipeline Deploy');\n\n      try {\n        // Mutually exclusive input sources — validated INSIDE the try so failures route\n        // through handleError (consistent exit code/format) like every other command.\n        if (!options.id && !options.localSpec) {\n          throw new Error('Either --id <pipeline-id> or --local-spec <path> is required');\n        }\n        if (options.id && options.localSpec) {\n          throw new Error('--id and --local-spec are mutually exclusive');\n        }\n\n        auditLog('deploy', { executionId, pipelineId: options.id, profile: options.profile });\n\n        printInfo('Deployment parameters', {\n          id: options.id,\n          awsProfile: options.profile,\n          outputDir: options.output,\n          requireApproval: options.requireApproval,\n          verifySsl: options.verifySsl,\n        });\n\n        // Security warning for SSL verification disabled\n        printSslWarning(options.verifySsl);\n\n        // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it,\n        // but refuse in production (see relaxTlsForCli) — the flag disables cert\n        // validation for ALL outbound TLS, including the AWS SDK.\n        relaxTlsForCli(options.verifySsl, printWarning);\n\n        // Local-tool prerequisites (cdk + esbuild/pnpm) are verified up front by\n        // the CLI's preAction hook, so by here they're guaranteed present.\n\n        let pipeline: Pipeline;\n        let propsWithIds: Record<string, unknown>;\n        // Remote-mode registry-post handles — null in --local-spec mode.\n        let platformClient: Awaited<ReturnType<typeof createAuthenticatedClientAsync>> | undefined;\n        let platformConfig: PlatformDeployConfig | undefined;\n\n        if (options.localSpec) {\n          // --local-spec: read pipeline.json from disk; no platform contact.\n          // Compliance / quota / plugin-lookup features all require the platform —\n          // this mode is for air-gapped or simple standalone CDK deployments.\n          const absPath = path.resolve(options.localSpec);\n          printInfo('Loading local pipeline spec', { path: absPath });\n          if (!fs.existsSync(absPath)) {\n            throw new Error(`Local spec file not found: ${absPath}`);\n          }\n          const raw = fs.readFileSync(absPath, 'utf-8');\n          const parsed = JSON.parse(raw) as Partial<Pipeline> & { props?: Record<string, unknown> };\n          if (!parsed.props) {\n            throw new Error(`Local spec file is missing required 'props' field: ${absPath}`);\n          }\n          pipeline = {\n            id: parsed.id ?? 'local',\n            project: parsed.project ?? 'local-project',\n            organization: parsed.organization ?? 'local-org',\n            orgId: parsed.orgId,\n            isDefault: parsed.isDefault ?? false,\n            isActive: parsed.isActive ?? true,\n            props: parsed.props,\n          } as Pipeline;\n          printSuccess('Local spec loaded');\n          printKeyValue({\n            Source: absPath,\n            Project: pipeline.project,\n            Organization: pipeline.organization,\n          });\n          propsWithIds = {\n            ...pipeline.props,\n            ...(pipeline.orgId && { orgId: pipeline.orgId }),\n            pipelineId: pipeline.id,\n          };\n        } else {\n          // Remote path: fetch config from platform API. fetchPipelineProps does\n          // the fetch + plugin pre-resolution + registry pull-host bake — shared\n          // verbatim with `synth` so the two never drift.\n          platformClient = await createAuthenticatedClientAsync(options);\n          platformConfig = platformClient.getConfig() as PlatformDeployConfig;\n\n          printInfo('Fetching pipeline configuration', { id: options.id });\n          const fetched = await fetchPipelineProps(platformClient, options.id);\n          pipeline = fetched.pipeline;\n          propsWithIds = fetched.propsWithIds;\n\n          printSuccess('Pipeline configuration retrieved');\n          printKeyValue({\n            'ID': pipeline.id,\n            'Project': pipeline.project,\n            'Organization': pipeline.organization,\n            'Is Default': pipeline.isDefault,\n            'Is Active': pipeline.isActive,\n          });\n        }\n\n        // --show-resolved: print resolved config and exit (no CDK deploy)\n        if ((options as { showResolved?: boolean }).showResolved) {\n          await printResolvedOrExit(propsWithIds);\n          return;\n        }\n\n        // Steps 5–9 (encode props → cdk deploy → register ARN) are shared with\n        // `pipeline create --deploy` via runDeploy so the two never drift.\n        await runDeploy({\n          pipeline,\n          propsWithIds,\n          profile: options.profile,\n          region: options.region,\n          requireApproval: options.requireApproval,\n          output: options.output,\n          debug: program.opts().debug,\n          executionId,\n          platformClient,\n          platformPipelineUrl: platformConfig?.api.pipelineUrl,\n          platformBaseUrl: platformConfig?.api.baseUrl,\n        });\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'deploy',\n            executionId,\n            pipelineId: options.id,\n            verifySsl: options.verifySsl,\n          },\n        });\n      }\n    });\n}\n"]}