@pipeline-builder/pipeline-manager 3.1.0

package/dist/commands/store-token.js

@@ -0,0 +1,233 @@
+"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.storeToken = storeToken;
+const pipeline_core_1 = require("@pipeline-builder/pipeline-core");
+const axios_1 = __importDefault(require("axios"));
+const cli_constants_1 = require("../config/cli.constants");
+const audit_log_1 = require("../utils/audit-log");
+const auth_guard_1 = require("../utils/auth-guard");
+const aws_secrets_1 = require("../utils/aws-secrets");
+const command_utils_1 = require("../utils/command-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");
+/**
+ * Build the secret name from the JWT token's organizationId.
+ * Pattern: {SECRETS_PATH_PREFIX}/{orgId}/platform
+ * @throws Error if organizationId is not present in the token
+ */
+function resolveSecretName(token) {
+    const payload = (0, auth_guard_1.decodeTokenPayload)(token);
+    const orgId = payload?.organizationId;
+    if (!orgId) {
+        throw new Error('Token does not contain organizationId — cannot derive secret name. Use --secret-name to specify explicitly.');
+    }
+    return `${pipeline_core_1.CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;
+}
+/**
+ * Registers the `store-token` command with the CLI program.
+ *
+ * Generates a long-lived JWT token via the platform API and stores it
+ * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.
+ *
+ * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager store-token --region us-east-1
+ * pipeline-manager store-token --days 90 --region us-east-1
+ * pipeline-manager store-token --days 7 --secret-name my-custom-secret --no-verify-ssl
+ * pipeline-manager store-token --dry-run
+ * pipeline-manager store-token -e admin -p '***' --region us-east-1
+ * ```
+ */
+function storeToken(program) {
+    program
+        .command('store-token')
+        .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')
+        .option('-e, --email <email>', 'Login email (skips PLATFORM_TOKEN requirement)')
+        .option('-p, --password <password>', 'Login password (used with --email)')
+        .option('--days <days>', 'Token lifetime in days', '30')
+        .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)
+        .option('--secret-name <name>', 'Secrets Manager secret name (default: derived from token org)')
+        .option('--region <region>', 'AWS region (defaults to AWS_REGION env)')
+        .option('--profile <profile>', 'AWS CLI profile', 'default')
+        .option('--json', 'Output result as JSON', false)
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification')
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('Store Token');
+        try {
+            (0, command_utils_1.printSslWarning)(options.verifySsl);
+            const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION || 'us-east-1';
+            const days = (0, cli_constants_1.validateNumber)(options.days, 'days', 1, 365);
+            const expiresInSeconds = days * 24 * 60 * 60;
+            // Step 0: If --email/--password provided and no PLATFORM_TOKEN, login first
+            if (options.email && options.password && !process.env.PLATFORM_TOKEN) {
+                (0, output_utils_1.printSection)('Login');
+                (0, output_utils_1.printInfo)('Authenticating with email/password...');
+                const config = (0, config_loader_1.getConfigWithOptions)(options);
+                const loginUrl = `${config.api.baseUrl}/api/auth/login`;
+                const loginResponse = await axios_1.default.post(loginUrl, {
+                    email: options.email,
+                    password: options.password,
+                }, {
+                    httpsAgent: config.api.rejectUnauthorized === false
+                        ? new (await Promise.resolve().then(() => __importStar(require('https')))).Agent({ rejectUnauthorized: false })
+                        : undefined,
+                });
+                const loginData = loginResponse.data?.data ?? loginResponse.data;
+                const loginToken = loginData?.accessToken;
+                if (!loginToken || typeof loginToken !== 'string') {
+                    throw new Error('Login failed — no access token in response');
+                }
+                process.env.PLATFORM_TOKEN = loginToken;
+                (0, output_utils_1.printSuccess)('Login successful');
+            }
+            // Step 1: Authenticate and generate long-lived token
+            (0, output_utils_1.printSection)('Generate Token');
+            const client = await (0, command_utils_1.createAuthenticatedClientAsync)(options);
+            // Resolve secret name from token's organizationId (unless --secret-name was explicitly set)
+            const secretName = options.secretName || resolveSecretName(process.env.PLATFORM_TOKEN);
+            (0, audit_log_1.auditLog)('store-token', { executionId, secretName, days: options.days, dryRun: options.dryRun });
+            (0, output_utils_1.printInfo)('Parameters', {
+                secretName,
+                region,
+                days,
+                expiresIn: `${expiresInSeconds}s`,
+                dryRun: options.dryRun,
+            });
+            (0, output_utils_1.printInfo)('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });
+            const tokenResponse = await client.post('/api/user/generate-token', { expiresIn: expiresInSeconds });
+            const tokenData = tokenResponse?.data ?? tokenResponse;
+            const accessToken = tokenData?.accessToken;
+            const refreshToken = tokenData?.refreshToken;
+            const actualExpiresIn = tokenData?.expiresIn ?? expiresInSeconds;
+            if (!accessToken) {
+                throw new Error('Token generation failed — no access token in response');
+            }
+            (0, output_utils_1.printSuccess)(`Token generated (expires in ${actualExpiresIn}s)`);
+            const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();
+            const secretValue = JSON.stringify({
+                accessToken,
+                ...(refreshToken && { refreshToken }),
+                platformUrl: client.getBaseUrl(),
+                expiresIn: actualExpiresIn,
+                expiresAt,
+                createdAt: new Date().toISOString(),
+            });
+            // Dry-run: show what would be stored
+            if (options.dryRun) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        dryRun: true,
+                        secretName,
+                        region,
+                        expiresInDays: days,
+                        expiresAt,
+                        tokenLength: accessToken.length,
+                        hasRefreshToken: !!refreshToken,
+                    }, null, 2));
+                }
+                else {
+                    console.log('');
+                    (0, output_utils_1.printSection)('Dry Run — No Changes Made');
+                    (0, output_utils_1.printKeyValue)({
+                        'Secret Name': secretName,
+                        'Region': region,
+                        'Expires In': `${days} days`,
+                        'Renew By': expiresAt,
+                        'Token Length': `${accessToken.length} chars`,
+                        'Has Refresh Token': refreshToken ? 'Yes' : 'No',
+                    });
+                    (0, output_utils_1.printSuccess)('Dry run complete — no secret was created or updated');
+                }
+                return;
+            }
+            // Step 2: Store token in Secrets Manager
+            (0, output_utils_1.printSection)('Store Token');
+            const description = `Platform JWT token (renew by ${expiresAt})`;
+            await (0, aws_secrets_1.upsertSecret)(secretName, secretValue, description, { region, profile: options.profile });
+            const arn = await (0, aws_secrets_1.getSecretArn)(secretName, { region, profile: options.profile });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: true,
+                    secretName,
+                    secretArn: arn,
+                    region,
+                    expiresInDays: days,
+                    expiresAt,
+                }, null, 2));
+            }
+            else {
+                console.log('');
+                (0, output_utils_1.printSection)('Token Stored');
+                (0, output_utils_1.printKeyValue)({
+                    'Secret Name': secretName,
+                    'Secret ARN': arn,
+                    'Region': region,
+                    'Expires In': `${days} days`,
+                    'Renew By': expiresAt,
+                    'Status': '✓ Stored',
+                });
+                console.log('');
+                (0, output_utils_1.printSuccess)('Token stored. To use with synth/deploy:');
+                (0, output_utils_1.printInfo)(`  export PLATFORM_SECRET_NAME=${secretName}`);
+                (0, output_utils_1.printInfo)('  pipeline-manager synth --id <pipeline-id> --store-tokens');
+                console.log('');
+                (0, output_utils_1.printInfo)(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'store-token',
+                    executionId,
+                    secretName: options.secretName || '(derived from token)',
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store-token.js","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport { validateNumber } from '../config/cli.constants';\nimport { auditLog } from '../utils/audit-log';\nimport { decodeTokenPayload } from '../utils/auth-guard';\nimport { upsertSecret, getSecretArn } from '../utils/aws-secrets';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils';\nimport { getConfigWithOptions } from '../utils/config-loader';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils';\n\n/**\n * Build the secret name from the JWT token's organizationId.\n * Pattern: {SECRETS_PATH_PREFIX}/{orgId}/platform\n * @throws Error if organizationId is not present in the token\n */\nfunction resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Use --secret-name to specify explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Registers the `store-token` command with the CLI program.\n *\n * Generates a long-lived JWT token via the platform API and stores it\n * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.\n *\n * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.\n *\n * @example\n * ```bash\n * pipeline-manager store-token --region us-east-1\n * pipeline-manager store-token --days 90 --region us-east-1\n * pipeline-manager store-token --days 7 --secret-name my-custom-secret --no-verify-ssl\n * pipeline-manager store-token --dry-run\n * pipeline-manager store-token -e admin -p '***' --region us-east-1\n * ```\n */\nexport function storeToken(program: Command): void {\n  program\n    .command('store-token')\n    .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')\n    .option('-e, --email <email>', 'Login email (skips PLATFORM_TOKEN requirement)')\n    .option('-p, --password <password>', 'Login password (used with --email)')\n    .option('--days <days>', 'Token lifetime in days', '30')\n    .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)\n    .option('--secret-name <name>', 'Secrets Manager secret name (default: derived from token org)')\n    .option('--region <region>', 'AWS region (defaults to AWS_REGION env)')\n    .option('--profile <profile>', 'AWS CLI profile', 'default')\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .action(async (options) => {\n      const executionId = printCommandHeader('Store Token');\n\n      try {\n        printSslWarning(options.verifySsl);\n\n        const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION || 'us-east-1';\n\n        const days = validateNumber(options.days, 'days', 1, 365);\n        const expiresInSeconds = days * 24 * 60 * 60;\n\n        // Step 0: If --email/--password provided and no PLATFORM_TOKEN, login first\n        if (options.email && options.password && !process.env.PLATFORM_TOKEN) {\n          printSection('Login');\n          printInfo('Authenticating with email/password...');\n\n          const config = getConfigWithOptions(options);\n          const loginUrl = `${config.api.baseUrl}/api/auth/login`;\n\n          const loginResponse = await axios.post(loginUrl, {\n            email: options.email,\n            password: options.password,\n          }, {\n            httpsAgent: config.api.rejectUnauthorized === false\n              ? new (await import('https')).Agent({ rejectUnauthorized: false })\n              : undefined,\n          });\n\n          const loginData = loginResponse.data?.data ?? loginResponse.data;\n          const loginToken = loginData?.accessToken;\n\n          if (!loginToken || typeof loginToken !== 'string') {\n            throw new Error('Login failed — no access token in response');\n          }\n\n          process.env.PLATFORM_TOKEN = loginToken;\n          printSuccess('Login successful');\n        }\n\n        // Step 1: Authenticate and generate long-lived token\n        printSection('Generate Token');\n\n        const client = await createAuthenticatedClientAsync(options);\n\n        // Resolve secret name from token's organizationId (unless --secret-name was explicitly set)\n        const secretName = options.secretName || resolveSecretName(process.env.PLATFORM_TOKEN!);\n\n        auditLog('store-token', { executionId, secretName, days: options.days, dryRun: options.dryRun });\n\n        printInfo('Parameters', {\n          secretName,\n          region,\n          days,\n          expiresIn: `${expiresInSeconds}s`,\n          dryRun: options.dryRun,\n        });\n\n        printInfo('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });\n\n        const tokenResponse = await client.post<Record<string, unknown>>(\n          '/api/user/generate-token',\n          { expiresIn: expiresInSeconds },\n        );\n\n        const tokenData = (tokenResponse as Record<string, unknown>)?.data ?? tokenResponse;\n        const accessToken = (tokenData as Record<string, unknown>)?.accessToken as string | undefined;\n        const refreshToken = (tokenData as Record<string, unknown>)?.refreshToken as string | undefined;\n        const actualExpiresIn = ((tokenData as Record<string, unknown>)?.expiresIn as number) ?? expiresInSeconds;\n\n        if (!accessToken) {\n          throw new Error('Token generation failed — no access token in response');\n        }\n\n        printSuccess(`Token generated (expires in ${actualExpiresIn}s)`);\n\n        const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();\n\n        const secretValue = JSON.stringify({\n          accessToken,\n          ...(refreshToken && { refreshToken }),\n          platformUrl: client.getBaseUrl(),\n          expiresIn: actualExpiresIn,\n          expiresAt,\n          createdAt: new Date().toISOString(),\n        });\n\n        // Dry-run: show what would be stored\n        if (options.dryRun) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              dryRun: true,\n              secretName,\n              region,\n              expiresInDays: days,\n              expiresAt,\n              tokenLength: accessToken.length,\n              hasRefreshToken: !!refreshToken,\n            }, null, 2));\n          } else {\n            console.log('');\n            printSection('Dry Run — No Changes Made');\n            printKeyValue({\n              'Secret Name': secretName,\n              'Region': region,\n              'Expires In': `${days} days`,\n              'Renew By': expiresAt,\n              'Token Length': `${accessToken.length} chars`,\n              'Has Refresh Token': refreshToken ? 'Yes' : 'No',\n            });\n            printSuccess('Dry run complete — no secret was created or updated');\n          }\n          return;\n        }\n\n        // Step 2: Store token in Secrets Manager\n        printSection('Store Token');\n\n        const description = `Platform JWT token (renew by ${expiresAt})`;\n        await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });\n\n        const arn = await getSecretArn(secretName, { region, profile: options.profile });\n\n        if (options.json) {\n          console.log(JSON.stringify({\n            success: true,\n            secretName,\n            secretArn: arn,\n            region,\n            expiresInDays: days,\n            expiresAt,\n          }, null, 2));\n        } else {\n          console.log('');\n          printSection('Token Stored');\n\n          printKeyValue({\n            'Secret Name': secretName,\n            'Secret ARN': arn,\n            'Region': region,\n            'Expires In': `${days} days`,\n            'Renew By': expiresAt,\n            'Status': '✓ Stored',\n          });\n\n          console.log('');\n          printSuccess('Token stored. To use with synth/deploy:');\n          printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);\n          printInfo('  pipeline-manager synth --id <pipeline-id> --store-tokens');\n          console.log('');\n          printInfo(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'store-token',\n            executionId,\n            secretName: options.secretName || '(derived from token)',\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/synth.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+/**
+ * Registers the `synth` command with the CLI program.
+ *
+ * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:
+ * 1. --id flag or PIPELINE_ID env var → fetches config from platform API
+ * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)
+ *
+ * Authentication methods (in priority order):
+ * - PLATFORM_TOKEN env var
+ * - --store-tokens → fetch from AWS Secrets Manager
+ *
+ * @example
+ * ```bash
+ * pipeline-manager synth --id <pipeline-id> --no-verify-ssl
+ * pipeline-manager synth --id <pipeline-id> --store-tokens
+ * pipeline-manager synth --quiet --no-notices          # CodePipeline (uses env vars)
+ * ```
+ */
+export declare function synth(program: Command): void;
+//# sourceMappingURL=synth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"synth.d.ts","sourceRoot":"","sources":["../../src/commands/synth.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyCpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+F5C"}

package/dist/commands/synth.js

@@ -0,0 +1,143 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synth = synth;
+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");
+/**
+ * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.
+ * Uses createAuthenticatedClientAsync which supports all three auth methods.
+ */
+async function fetchPipelineConfig(pipelineId, options) {
+    const client = await (0, command_utils_1.createAuthenticatedClientAsync)(options);
+    const config = client.getConfig();
+    const response = await client.get(`${config.api.pipelineUrl}/${pipelineId}`);
+    const pipeline = (0, output_utils_1.extractSingleResponse)(response, 'pipeline', 'props');
+    if (!pipeline?.props) {
+        (0, output_utils_1.printError)('Pipeline has no props', { id: pipelineId });
+        throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);
+    }
+    const propsWithIds = {
+        ...pipeline.props,
+        pipelineId: pipeline.id || pipelineId,
+    };
+    if (pipeline.orgId)
+        propsWithIds.orgId = pipeline.orgId;
+    process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');
+    (0, output_utils_1.printSuccess)('Pipeline configuration loaded');
+}
+/**
+ * Registers the `synth` command with the CLI program.
+ *
+ * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:
+ * 1. --id flag or PIPELINE_ID env var → fetches config from platform API
+ * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)
+ *
+ * Authentication methods (in priority order):
+ * - PLATFORM_TOKEN env var
+ * - --store-tokens → fetch from AWS Secrets Manager
+ *
+ * @example
+ * ```bash
+ * pipeline-manager synth --id <pipeline-id> --no-verify-ssl
+ * pipeline-manager synth --id <pipeline-id> --store-tokens
+ * pipeline-manager synth --quiet --no-notices          # CodePipeline (uses env vars)
+ * ```
+ */
+function synth(program) {
+    program
+        .command('synth')
+        .description('Run CDK synthesis using pipeline configuration')
+        .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')
+        .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)
+        .option('--output <dir>', 'CDK output directory', 'cdk.out')
+        .option('--profile <profile>', 'AWS profile')
+        .option('--region <region>', 'AWS region (for --store-tokens)')
+        .option('--quiet', 'Suppress CDK output', false)
+        .option('--no-notices', 'Suppress CDK notices')
+        .option('--verbose', 'Show verbose CDK output', false)
+        .option('--json', 'Output result as JSON', false)
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification')
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('CDK Synthesis');
+        try {
+            const pipelineId = options.id || process.env.PIPELINE_ID;
+            (0, audit_log_1.auditLog)('synth', { executionId, pipelineId, output: options.output, profile: options.profile });
+            (0, command_utils_1.printSslWarning)(options.verifySsl);
+            // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it
+            if (options.verifySsl === false) {
+                process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            }
+            // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set
+            if (pipelineId && !process.env.PIPELINE_PROPS) {
+                (0, output_utils_1.printInfo)('Fetching pipeline configuration', { id: pipelineId });
+                await fetchPipelineConfig(pipelineId, options);
+            }
+            else if (!pipelineId && !process.env.PIPELINE_PROPS) {
+                (0, output_utils_1.printWarning)('No pipeline ID or PIPELINE_PROPS set');
+                throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');
+            }
+            (0, cdk_utils_1.ensureCdkAvailable)();
+            (0, output_utils_1.printSuccess)('AWS CDK is available');
+            // Build cdk synth command
+            if (options.output)
+                (0, cli_constants_1.assertShellSafe)(options.output, 'output');
+            if (options.profile)
+                (0, cli_constants_1.assertShellSafe)(options.profile, 'profile');
+            const boilerplatePath = (0, cdk_utils_1.resolveBoilerplatePath)(__dirname);
+            const parts = [
+                'cdk synth',
+                `--app="node ${boilerplatePath}"`,
+                `--output=${options.output}`,
+            ];
+            if (options.profile)
+                parts.push(`--profile=${options.profile}`);
+            if (options.quiet)
+                parts.push('--quiet');
+            if (options.notices === false)
+                parts.push('--no-notices');
+            if (options.verbose)
+                parts.push('--verbose');
+            const command = parts.join(' ');
+            (0, output_utils_1.printInfo)('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });
+            console.log('');
+            const result = (0, cdk_utils_1.executeCdkShellCommand)(command, {
+                showOutput: !options.quiet,
+            });
+            console.log('');
+            (0, output_utils_1.printSection)('Synthesis Complete');
+            if (result.success) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        executionId,
+                        duration: result.duration,
+                        output: options.output,
+                    }, null, 2));
+                }
+                else {
+                    (0, output_utils_1.printKeyValue)({
+                        'Execution ID': executionId,
+                        'Duration': `${result.duration}ms`,
+                        'Output': options.output,
+                        'Status': '✓ Success',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'synth', executionId, pipelineId: options.id },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth.js","sourceRoot":"","sources":["../../src/commands/synth.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 { assertShellSafe } from '../config/cli.constants';\nimport type { Pipeline } from '../types/pipeline';\nimport { auditLog } from '../utils/audit-log';\nimport { ensureCdkAvailable, executeCdkShellCommand, resolveBoilerplatePath } from '../utils/cdk-utils';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { extractSingleResponse, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils';\n\n/**\n * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.\n * Uses createAuthenticatedClientAsync which supports all three auth methods.\n */\nasync function fetchPipelineConfig(\n  pipelineId: string,\n  options: { storeTokens?: boolean; verifySsl?: boolean; region?: string; profile?: string },\n): Promise<void> {\n  const client = await createAuthenticatedClientAsync(options);\n  const config = client.getConfig();\n\n  const response = await client.get<Record<string, unknown>>(\n    `${config.api.pipelineUrl}/${pipelineId}`,\n  );\n\n  const pipeline = extractSingleResponse<Pipeline>(response, 'pipeline', 'props');\n\n  if (!pipeline?.props) {\n    printError('Pipeline has no props', { id: pipelineId });\n    throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);\n  }\n\n  const propsWithIds: Record<string, unknown> = {\n    ...pipeline.props as Record<string, unknown>,\n    pipelineId: pipeline.id || pipelineId,\n  };\n  if (pipeline.orgId) propsWithIds.orgId = pipeline.orgId;\n\n  process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');\n  printSuccess('Pipeline configuration loaded');\n}\n\n/**\n * Registers the `synth` command with the CLI program.\n *\n * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:\n * 1. --id flag or PIPELINE_ID env var → fetches config from platform API\n * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)\n *\n * Authentication methods (in priority order):\n * - PLATFORM_TOKEN env var\n * - --store-tokens → fetch from AWS Secrets Manager\n *\n * @example\n * ```bash\n * pipeline-manager synth --id <pipeline-id> --no-verify-ssl\n * pipeline-manager synth --id <pipeline-id> --store-tokens\n * pipeline-manager synth --quiet --no-notices          # CodePipeline (uses env vars)\n * ```\n */\nexport function synth(program: Command): void {\n  program\n    .command('synth')\n    .description('Run CDK synthesis using pipeline configuration')\n    .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')\n    .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)\n    .option('--output <dir>', 'CDK output directory', 'cdk.out')\n    .option('--profile <profile>', 'AWS profile')\n    .option('--region <region>', 'AWS region (for --store-tokens)')\n    .option('--quiet', 'Suppress CDK output', false)\n    .option('--no-notices', 'Suppress CDK notices')\n    .option('--verbose', 'Show verbose CDK output', false)\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Synthesis');\n\n      try {\n        const pipelineId = options.id || process.env.PIPELINE_ID;\n\n        auditLog('synth', { executionId, pipelineId, output: options.output, profile: options.profile });\n        printSslWarning(options.verifySsl);\n\n        // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it\n        if (options.verifySsl === false) {\n          process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';\n        }\n\n        // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set\n        if (pipelineId && !process.env.PIPELINE_PROPS) {\n          printInfo('Fetching pipeline configuration', { id: pipelineId });\n          await fetchPipelineConfig(pipelineId, options);\n        } else if (!pipelineId && !process.env.PIPELINE_PROPS) {\n          printWarning('No pipeline ID or PIPELINE_PROPS set');\n          throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');\n        }\n\n        ensureCdkAvailable();\n        printSuccess('AWS CDK is available');\n\n        // Build cdk synth command\n        if (options.output) assertShellSafe(options.output, 'output');\n        if (options.profile) assertShellSafe(options.profile, 'profile');\n\n        const boilerplatePath = resolveBoilerplatePath(__dirname);\n        const parts = [\n          'cdk synth',\n          `--app=\"node ${boilerplatePath}\"`,\n          `--output=${options.output}`,\n        ];\n\n        if (options.profile) parts.push(`--profile=${options.profile}`);\n        if (options.quiet) parts.push('--quiet');\n        if (options.notices === false) parts.push('--no-notices');\n        if (options.verbose) parts.push('--verbose');\n\n        const command = parts.join(' ');\n\n        printInfo('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });\n        console.log('');\n\n        const result = executeCdkShellCommand(command, {\n          showOutput: !options.quiet,\n        });\n\n        console.log('');\n        printSection('Synthesis Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              duration: result.duration,\n              output: options.output,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Duration': `${result.duration}ms`,\n              'Output': options.output,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'synth', executionId, pipelineId: options.id },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/upload-plugin.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+/**
+ * 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
+ * ```
+ */
+export declare function uploadPlugin(program: Command): void;
+//# sourceMappingURL=upload-plugin.d.ts.map

package/dist/commands/upload-plugin.d.ts.map

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