@pipeline-builder/pipeline-manager 3.1.0

package/dist/commands/login.js

@@ -0,0 +1,179 @@
+"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.login = login;
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const cli_constants_1 = require("../config/cli.constants");
+const error_handler_1 = require("../utils/error-handler");
+const output_utils_1 = require("../utils/output-utils");
+const rate_limiter_1 = require("../utils/rate-limiter");
+const { bold, cyan, green, magenta } = picocolors_1.default;
+/**
+ * Registers the `login` command with the CLI program.
+ *
+ * Authenticates against the platform API and prints an export statement
+ * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`
+ * to be set beforehand (unlike other commands).
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager login --identifier admin@example.com --password secret
+ * pipeline-manager login -u admin@example.com -p secret
+ * pipeline-manager login -u admin@example.com -p secret --url https://myhost:8443
+ * eval $(pipeline-manager login -u admin@example.com -p secret --quiet)
+ * pipeline-manager login --refresh <refresh-token>
+ * ```
+ */
+function login(program) {
+    program
+        .command('login')
+        .description('Authenticate with the platform and obtain a PLATFORM_TOKEN')
+        .option('-u, --identifier <identifier>', 'Username or email')
+        .option('-p, --password <password>', 'Password')
+        .option('--refresh <refreshToken>', 'Use a refresh token instead of login credentials')
+        .option('--org <orgId>', 'Switch to a specific organization after login')
+        .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443')
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification')
+        .option('--quiet', 'Only print the export statement (useful for eval)')
+        .action(async (options) => {
+        const executionId = (0, cli_constants_1.generateExecutionId)();
+        const isRefresh = !!options.refresh;
+        try {
+            // Validate required options
+            if (!isRefresh && (!options.identifier || !options.password)) {
+                (0, output_utils_1.printError)('Login requires --identifier and --password, or --refresh <token>');
+                process.exit(error_handler_1.ERROR_CODES.AUTHENTICATION);
+            }
+            // Rate limiting — prevent brute force (login only)
+            if (!isRefresh) {
+                const rateLimitMsg = (0, rate_limiter_1.checkAuthRateLimit)();
+                if (rateLimitMsg) {
+                    (0, output_utils_1.printError)(rateLimitMsg);
+                    process.exit(error_handler_1.ERROR_CODES.AUTHENTICATION);
+                }
+            }
+            const quiet = options.quiet ?? false;
+            if (!quiet) {
+                (0, output_utils_1.printSection)(isRefresh ? 'Token Refresh' : 'Login');
+                console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(isRefresh ? 'Token Refresh' : 'Platform Authentication'))}`);
+                console.log('');
+                (0, output_utils_1.printInfo)(isRefresh ? 'Refreshing access token' : 'Authenticating', {
+                    ...(options.identifier ? { identifier: options.identifier } : {}),
+                    url: options.url,
+                    verifySsl: options.verifySsl,
+                });
+            }
+            const httpsAgent = new https_1.default.Agent({
+                rejectUnauthorized: options.verifySsl ?? true,
+            });
+            let token;
+            if (isRefresh) {
+                const refreshUrl = `${options.url}/api/auth/refresh`;
+                (0, output_utils_1.printDebug)('POST', { url: refreshUrl });
+                const response = await axios_1.default.post(refreshUrl, { refreshToken: options.refresh }, {
+                    headers: { 'Content-Type': 'application/json' },
+                    httpsAgent,
+                    timeout: cli_constants_1.TIMEOUTS.HTTP_REQUEST,
+                });
+                token = response.data?.data?.accessToken;
+            }
+            else {
+                const loginUrl = `${options.url}/api/auth/login`;
+                (0, output_utils_1.printDebug)('POST', { url: loginUrl });
+                const response = await axios_1.default.post(loginUrl, {
+                    identifier: options.identifier,
+                    password: options.password,
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                    httpsAgent,
+                    timeout: cli_constants_1.TIMEOUTS.HTTP_REQUEST,
+                });
+                token = response.data?.data?.accessToken;
+            }
+            if (!token) {
+                if (!isRefresh)
+                    (0, rate_limiter_1.recordAuthFailure)();
+                (0, output_utils_1.printError)(`${isRefresh ? 'Token refresh' : 'Login'} failed: no access token in response`);
+                process.exit(error_handler_1.ERROR_CODES.AUTHENTICATION);
+            }
+            if (!isRefresh)
+                (0, rate_limiter_1.recordAuthSuccess)();
+            // Switch to a specific organization if --org is provided
+            if (options.org) {
+                if (!quiet) {
+                    (0, output_utils_1.printInfo)('Switching to organization', { orgId: options.org });
+                }
+                const switchUrl = `${options.url}/api/auth/switch-org`;
+                (0, output_utils_1.printDebug)('POST', { url: switchUrl });
+                const switchResponse = await axios_1.default.post(switchUrl, { organizationId: options.org }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${token}`,
+                    },
+                    httpsAgent,
+                    timeout: cli_constants_1.TIMEOUTS.HTTP_REQUEST,
+                });
+                const switchedToken = switchResponse.data?.data?.accessToken;
+                if (!switchedToken) {
+                    (0, output_utils_1.printError)('Organization switch failed: no access token in response');
+                    process.exit(error_handler_1.ERROR_CODES.AUTHENTICATION);
+                }
+                token = switchedToken;
+                if (!quiet) {
+                    (0, output_utils_1.printSuccess)(`Switched to organization ${options.org}`);
+                }
+            }
+            if (!quiet) {
+                console.log('');
+                (0, output_utils_1.printSuccess)(isRefresh ? 'Token refreshed successfully' : 'Login successful');
+                console.log('');
+            }
+            console.log(`export PLATFORM_TOKEN=${token}`);
+            if (!quiet) {
+                console.log('');
+                (0, output_utils_1.printInfo)('Tip: Run the following to set the token in your shell:');
+                const orgFlag = options.org ? ` --org ${options.org}` : '';
+                if (isRefresh) {
+                    console.log(green(`  eval $(pipeline-manager login --refresh '<refresh-token>'${orgFlag} --quiet)`));
+                }
+                else {
+                    console.log(green(`  eval $(pipeline-manager login -u ${options.identifier} -p '***'${orgFlag} --quiet)`));
+                }
+            }
+        }
+        catch (error) {
+            if (!isRefresh)
+                (0, rate_limiter_1.recordAuthFailure)();
+            // Provide a clear failure message for auth errors
+            if (axios_1.default.isAxiosError(error)) {
+                const status = error.response?.status;
+                const message = error.response?.data?.message;
+                (0, output_utils_1.printError)(`${isRefresh ? 'Token refresh' : 'Login'} failed`, {
+                    status: status ?? 'no response',
+                    ...(message ? { message } : {}),
+                });
+                process.exit(error_handler_1.ERROR_CODES.AUTHENTICATION);
+            }
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.AUTHENTICATION, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'login',
+                    executionId,
+                    identifier: options.identifier,
+                    url: options.url,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login.js","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { generateExecutionId, TIMEOUTS } from '../config/cli.constants';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { printDebug, printError, printInfo, printSection, printSuccess } from '../utils/output-utils';\nimport { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter';\n\nconst { bold, cyan, green, magenta } = pico;\n\n/**\n * Expected shape of the login/refresh API response.\n */\ninterface LoginResponse {\n  success: boolean;\n  data: {\n    accessToken: string;\n    refreshToken: string;\n  };\n}\n\n/**\n * Registers the `login` command with the CLI program.\n *\n * Authenticates against the platform API and prints an export statement\n * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`\n * to be set beforehand (unlike other commands).\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * pipeline-manager login --identifier admin@example.com --password secret\n * pipeline-manager login -u admin@example.com -p secret\n * pipeline-manager login -u admin@example.com -p secret --url https://myhost:8443\n * eval $(pipeline-manager login -u admin@example.com -p secret --quiet)\n * pipeline-manager login --refresh <refresh-token>\n * ```\n */\nexport function login(program: Command): void {\n  program\n    .command('login')\n    .description('Authenticate with the platform and obtain a PLATFORM_TOKEN')\n    .option('-u, --identifier <identifier>', 'Username or email')\n    .option('-p, --password <password>', 'Password')\n    .option('--refresh <refreshToken>', 'Use a refresh token instead of login credentials')\n    .option('--org <orgId>', 'Switch to a specific organization after login')\n    .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443')\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .option('--quiet', 'Only print the export statement (useful for eval)')\n    .action(async (options) => {\n      const executionId = generateExecutionId();\n      const isRefresh = !!options.refresh;\n\n      try {\n\n        // Validate required options\n        if (!isRefresh && (!options.identifier || !options.password)) {\n          printError('Login requires --identifier and --password, or --refresh <token>');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        // Rate limiting — prevent brute force (login only)\n        if (!isRefresh) {\n          const rateLimitMsg = checkAuthRateLimit();\n          if (rateLimitMsg) {\n            printError(rateLimitMsg);\n            process.exit(ERROR_CODES.AUTHENTICATION);\n          }\n        }\n\n        const quiet = options.quiet ?? false;\n\n        if (!quiet) {\n          printSection(isRefresh ? 'Token Refresh' : 'Login');\n          console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(isRefresh ? 'Token Refresh' : 'Platform Authentication'))}`);\n          console.log('');\n          printInfo(isRefresh ? 'Refreshing access token' : 'Authenticating', {\n            ...(options.identifier ? { identifier: options.identifier } : {}),\n            url: options.url,\n            verifySsl: options.verifySsl,\n          });\n        }\n\n        const httpsAgent = new https.Agent({\n          rejectUnauthorized: options.verifySsl ?? true,\n        });\n\n        let token: string | undefined;\n\n        if (isRefresh) {\n          const refreshUrl = `${options.url}/api/auth/refresh`;\n          printDebug('POST', { url: refreshUrl });\n\n          const response = await axios.post<LoginResponse>(\n            refreshUrl,\n            { refreshToken: options.refresh },\n            {\n              headers: { 'Content-Type': 'application/json' },\n              httpsAgent,\n              timeout: TIMEOUTS.HTTP_REQUEST,\n            },\n          );\n\n          token = response.data?.data?.accessToken;\n        } else {\n          const loginUrl = `${options.url}/api/auth/login`;\n          printDebug('POST', { url: loginUrl });\n\n          const response = await axios.post<LoginResponse>(\n            loginUrl,\n            {\n              identifier: options.identifier,\n              password: options.password,\n            },\n            {\n              headers: { 'Content-Type': 'application/json' },\n              httpsAgent,\n              timeout: TIMEOUTS.HTTP_REQUEST,\n            },\n          );\n\n          token = response.data?.data?.accessToken;\n        }\n\n        if (!token) {\n          if (!isRefresh) recordAuthFailure();\n          printError(`${isRefresh ? 'Token refresh' : 'Login'} failed: no access token in response`);\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        if (!isRefresh) recordAuthSuccess();\n\n        // Switch to a specific organization if --org is provided\n        if (options.org) {\n          if (!quiet) {\n            printInfo('Switching to organization', { orgId: options.org });\n          }\n\n          const switchUrl = `${options.url}/api/auth/switch-org`;\n          printDebug('POST', { url: switchUrl });\n\n          const switchResponse = await axios.post<LoginResponse>(\n            switchUrl,\n            { organizationId: options.org },\n            {\n              headers: {\n                'Content-Type': 'application/json',\n                'Authorization': `Bearer ${token}`,\n              },\n              httpsAgent,\n              timeout: TIMEOUTS.HTTP_REQUEST,\n            },\n          );\n\n          const switchedToken = switchResponse.data?.data?.accessToken;\n          if (!switchedToken) {\n            printError('Organization switch failed: no access token in response');\n            process.exit(ERROR_CODES.AUTHENTICATION);\n          }\n\n          token = switchedToken;\n\n          if (!quiet) {\n            printSuccess(`Switched to organization ${options.org}`);\n          }\n        }\n\n        if (!quiet) {\n          console.log('');\n          printSuccess(isRefresh ? 'Token refreshed successfully' : 'Login successful');\n          console.log('');\n        }\n\n        console.log(`export PLATFORM_TOKEN=${token}`);\n\n        if (!quiet) {\n          console.log('');\n          printInfo('Tip: Run the following to set the token in your shell:');\n          const orgFlag = options.org ? ` --org ${options.org}` : '';\n          if (isRefresh) {\n            console.log(green(`  eval $(pipeline-manager login --refresh '<refresh-token>'${orgFlag} --quiet)`));\n          } else {\n            console.log(green(`  eval $(pipeline-manager login -u ${options.identifier} -p '***'${orgFlag} --quiet)`));\n          }\n        }\n      } catch (error) {\n        if (!isRefresh) recordAuthFailure();\n        // Provide a clear failure message for auth errors\n        if (axios.isAxiosError(error)) {\n          const status = error.response?.status;\n          const message = (error.response?.data as { message?: string })?.message;\n\n          printError(`${isRefresh ? 'Token refresh' : 'Login'} failed`, {\n            status: status ?? 'no response',\n            ...(message ? { message } : {}),\n          });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        handleError(error, ERROR_CODES.AUTHENTICATION, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'login',\n            executionId,\n            identifier: options.identifier,\n            url: options.url,\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/setup-events.d.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+/**
+ * Registers the `setup-events` command with the CLI program.
+ *
+ * Deploys EventBridge → SQS → Lambda infrastructure for pipeline reporting.
+ *
+ * 1. Deploys CloudFormation stack (rule + queue + Lambda shell + IAM)
+ * 2. Downloads @pipeline-builder/event-bridge from npm registry
+ * 3. Uploads handler code directly to Lambda (no S3 needed)
+ *
+ * Uses PLATFORM_BASE_URL from environment (same as all other commands).
+ * Idempotent — running again updates the stack and code.
+ */
+export declare function setupEvents(program: Command): void;
+//# sourceMappingURL=setup-events.d.ts.map

package/dist/commands/setup-events.d.ts.map

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

package/dist/commands/setup-events.js

@@ -0,0 +1,177 @@
+"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.setupEvents = setupEvents;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path_1 = __importDefault(require("path"));
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+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 STACK_NAME = 'pipeline-builder-events';
+// Existing CFN-managed Lambda function name — do NOT rename without a migration plan
+const LAMBDA_NAME = 'pipeline-builder-event-ingestion';
+const PACKAGE_NAME = '@pipeline-builder/event-bridge';
+/**
+ * Registers the `setup-events` command with the CLI program.
+ *
+ * Deploys EventBridge → SQS → Lambda infrastructure for pipeline reporting.
+ *
+ * 1. Deploys CloudFormation stack (rule + queue + Lambda shell + IAM)
+ * 2. Downloads @pipeline-builder/event-bridge from npm registry
+ * 3. Uploads handler code directly to Lambda (no S3 needed)
+ *
+ * Uses PLATFORM_BASE_URL from environment (same as all other commands).
+ * Idempotent — running again updates the stack and code.
+ */
+function setupEvents(program) {
+    program
+        .command('setup-events')
+        .description('Deploy EventBridge event ingestion infrastructure for pipeline reporting')
+        .option('--package-version <version>', 'event-bridge package version (default: latest)')
+        .option('--secret-name <name>', 'Platform secret name (e.g. pipeline-builder/{orgId}/platform)')
+        .option('--region <region>', 'AWS region')
+        .option('--profile <profile>', 'AWS CLI profile', 'default')
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('Setup Event Ingestion');
+        try {
+            const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION;
+            if (!region) {
+                (0, output_utils_1.printError)('AWS region is required');
+                throw new Error('AWS region not provided');
+            }
+            const platformUrl = process.env.PLATFORM_BASE_URL;
+            if (!platformUrl) {
+                (0, output_utils_1.printError)('PLATFORM_BASE_URL environment variable is required');
+                throw new Error('PLATFORM_BASE_URL not set');
+            }
+            const secretName = options.secretName || process.env.PLATFORM_SECRET_NAME;
+            if (!secretName) {
+                (0, output_utils_1.printError)('--secret-name or PLATFORM_SECRET_NAME env var is required');
+                throw new Error('Platform secret name not provided');
+            }
+            (0, output_utils_1.printInfo)('Parameters', {
+                stack: STACK_NAME,
+                region,
+                platformUrl,
+                secretName,
+                packageVersion: options.packageVersion || 'latest',
+            });
+            // Step 1: Deploy CloudFormation (infra only — Lambda gets placeholder code)
+            (0, output_utils_1.printSection)('Deploy Infrastructure');
+            const templatePath = path_1.default.join(__dirname, '../templates/events-stack.json');
+            const cfnArgs = [
+                'cloudformation', 'deploy',
+                '--stack-name', STACK_NAME,
+                '--template-file', templatePath,
+                '--parameter-overrides',
+                `PlatformBaseUrl=${platformUrl}`,
+                `PlatformSecretName=${secretName}`,
+                '--capabilities', 'CAPABILITY_NAMED_IAM',
+                '--no-fail-on-empty-changeset',
+                '--region', region,
+            ];
+            if (options.profile)
+                cfnArgs.push('--profile', options.profile);
+            (0, child_process_1.execFileSync)('aws', cfnArgs, { stdio: 'inherit' });
+            (0, output_utils_1.printSuccess)('Infrastructure deployed');
+            // Step 2: Download handler from registry and upload to Lambda
+            (0, output_utils_1.printSection)('Deploy Lambda Code');
+            const tmpDir = fs.mkdtempSync(path_1.default.join(os.tmpdir(), 'event-ingestion-'));
+            try {
+                const versionSpec = options.packageVersion ? `${PACKAGE_NAME}@${options.packageVersion}` : PACKAGE_NAME;
+                (0, output_utils_1.printInfo)('Installing from registry', { package: versionSpec });
+                (0, child_process_1.execFileSync)('npm', ['install', '--prefix', tmpDir, versionSpec], { stdio: 'pipe' });
+                const handlerSrc = path_1.default.join(tmpDir, 'node_modules', PACKAGE_NAME, 'lib', 'index.js');
+                if (!fs.existsSync(handlerSrc)) {
+                    throw new Error(`Handler not found at ${handlerSrc}. Ensure the package is published.`);
+                }
+                // Get version from installed package
+                const pkgJsonPath = path_1.default.join(tmpDir, 'node_modules', PACKAGE_NAME, 'package.json');
+                const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                const version = pkgJson.version || 'unknown';
+                // ZIP the handler
+                const zipPath = path_1.default.join(tmpDir, 'index.zip');
+                (0, child_process_1.execFileSync)('zip', ['-j', zipPath, 'index.js'], { cwd: path_1.default.dirname(handlerSrc), stdio: 'pipe' });
+                // Upload directly to Lambda via SDK (no S3 needed)
+                (0, output_utils_1.printInfo)('Uploading code to Lambda', { function: LAMBDA_NAME, version });
+                const lambdaClient = new client_lambda_1.LambdaClient({ region });
+                await lambdaClient.send(new client_lambda_1.UpdateFunctionCodeCommand({
+                    FunctionName: LAMBDA_NAME,
+                    ZipFile: fs.readFileSync(zipPath),
+                }));
+                (0, output_utils_1.printSuccess)(`Lambda code deployed (${PACKAGE_NAME}@${version})`);
+            }
+            finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            // Step 3: Show outputs via SDK
+            const cfnClient = new client_cloudformation_1.CloudFormationClient({ region });
+            const describeResult = await cfnClient.send(new client_cloudformation_1.DescribeStacksCommand({ StackName: STACK_NAME }));
+            const outputs = describeResult.Stacks?.[0]?.Outputs ?? [];
+            const outputMap = Object.fromEntries(outputs.map(o => [o.OutputKey ?? '', o.OutputValue ?? '']));
+            console.log('');
+            (0, output_utils_1.printSection)('Event Ingestion Ready');
+            (0, output_utils_1.printKeyValue)({
+                'Stack': STACK_NAME,
+                'Region': region,
+                'Platform URL': platformUrl,
+                'Lambda': outputMap.LambdaFunctionArn || LAMBDA_NAME,
+                'Event Queue': outputMap.EventQueueUrl || '(see AWS console)',
+                'Dead Letter Queue': outputMap.DeadLetterQueueUrl || '(see AWS console)',
+                'EventBridge Rule': outputMap.EventRuleName || '(see AWS console)',
+                'Status': '✓ Deployed',
+            });
+            console.log('');
+            (0, output_utils_1.printSuccess)('EventBridge event ingestion is active.');
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'setup-events', executionId, stack: STACK_NAME },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup-events.js","sourceRoot":"","sources":["../../src/commands/setup-events.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { execFileSync } from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport path from 'path';\nimport { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';\nimport { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';\nimport { Command } from 'commander';\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 STACK_NAME = 'pipeline-builder-events';\n// Existing CFN-managed Lambda function name — do NOT rename without a migration plan\nconst LAMBDA_NAME = 'pipeline-builder-event-ingestion';\nconst PACKAGE_NAME = '@pipeline-builder/event-bridge';\n\n/**\n * Registers the `setup-events` command with the CLI program.\n *\n * Deploys EventBridge → SQS → Lambda infrastructure for pipeline reporting.\n *\n * 1. Deploys CloudFormation stack (rule + queue + Lambda shell + IAM)\n * 2. Downloads @pipeline-builder/event-bridge from npm registry\n * 3. Uploads handler code directly to Lambda (no S3 needed)\n *\n * Uses PLATFORM_BASE_URL from environment (same as all other commands).\n * Idempotent — running again updates the stack and code.\n */\nexport function setupEvents(program: Command): void {\n  program\n    .command('setup-events')\n    .description('Deploy EventBridge event ingestion infrastructure for pipeline reporting')\n    .option('--package-version <version>', 'event-bridge package version (default: latest)')\n    .option('--secret-name <name>', 'Platform secret name (e.g. pipeline-builder/{orgId}/platform)')\n    .option('--region <region>', 'AWS region')\n    .option('--profile <profile>', 'AWS CLI profile', 'default')\n    .action(async (options) => {\n      const executionId = printCommandHeader('Setup Event Ingestion');\n\n      try {\n        const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION;\n        if (!region) {\n          printError('AWS region is required');\n          throw new Error('AWS region not provided');\n        }\n\n        const platformUrl = process.env.PLATFORM_BASE_URL;\n        if (!platformUrl) {\n          printError('PLATFORM_BASE_URL environment variable is required');\n          throw new Error('PLATFORM_BASE_URL not set');\n        }\n\n        const secretName = options.secretName || process.env.PLATFORM_SECRET_NAME;\n        if (!secretName) {\n          printError('--secret-name or PLATFORM_SECRET_NAME env var is required');\n          throw new Error('Platform secret name not provided');\n        }\n\n        printInfo('Parameters', {\n          stack: STACK_NAME,\n          region,\n          platformUrl,\n          secretName,\n          packageVersion: options.packageVersion || 'latest',\n        });\n\n        // Step 1: Deploy CloudFormation (infra only — Lambda gets placeholder code)\n        printSection('Deploy Infrastructure');\n\n        const templatePath = path.join(__dirname, '../templates/events-stack.json');\n\n        const cfnArgs = [\n          'cloudformation', 'deploy',\n          '--stack-name', STACK_NAME,\n          '--template-file', templatePath,\n          '--parameter-overrides',\n          `PlatformBaseUrl=${platformUrl}`,\n          `PlatformSecretName=${secretName}`,\n          '--capabilities', 'CAPABILITY_NAMED_IAM',\n          '--no-fail-on-empty-changeset',\n          '--region', region,\n        ];\n        if (options.profile) cfnArgs.push('--profile', options.profile);\n\n        execFileSync('aws', cfnArgs, { stdio: 'inherit' });\n\n        printSuccess('Infrastructure deployed');\n\n        // Step 2: Download handler from registry and upload to Lambda\n        printSection('Deploy Lambda Code');\n\n        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'event-ingestion-'));\n\n        try {\n          const versionSpec = options.packageVersion ? `${PACKAGE_NAME}@${options.packageVersion}` : PACKAGE_NAME;\n          printInfo('Installing from registry', { package: versionSpec });\n\n          execFileSync('npm', ['install', '--prefix', tmpDir, versionSpec], { stdio: 'pipe' });\n\n          const handlerSrc = path.join(tmpDir, 'node_modules', PACKAGE_NAME, 'lib', 'index.js');\n          if (!fs.existsSync(handlerSrc)) {\n            throw new Error(`Handler not found at ${handlerSrc}. Ensure the package is published.`);\n          }\n\n          // Get version from installed package\n          const pkgJsonPath = path.join(tmpDir, 'node_modules', PACKAGE_NAME, 'package.json');\n          const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));\n          const version = pkgJson.version || 'unknown';\n\n          // ZIP the handler\n          const zipPath = path.join(tmpDir, 'index.zip');\n          execFileSync('zip', ['-j', zipPath, 'index.js'], { cwd: path.dirname(handlerSrc), stdio: 'pipe' });\n\n          // Upload directly to Lambda via SDK (no S3 needed)\n          printInfo('Uploading code to Lambda', { function: LAMBDA_NAME, version });\n\n          const lambdaClient = new LambdaClient({ region });\n          await lambdaClient.send(new UpdateFunctionCodeCommand({\n            FunctionName: LAMBDA_NAME,\n            ZipFile: fs.readFileSync(zipPath),\n          }));\n\n          printSuccess(`Lambda code deployed (${PACKAGE_NAME}@${version})`);\n\n        } finally {\n          fs.rmSync(tmpDir, { recursive: true, force: true });\n        }\n\n        // Step 3: Show outputs via SDK\n        const cfnClient = new CloudFormationClient({ region });\n        const describeResult = await cfnClient.send(new DescribeStacksCommand({ StackName: STACK_NAME }));\n        const outputs = describeResult.Stacks?.[0]?.Outputs ?? [];\n        const outputMap = Object.fromEntries(outputs.map(o => [o.OutputKey ?? '', o.OutputValue ?? '']));\n\n        console.log('');\n        printSection('Event Ingestion Ready');\n\n        printKeyValue({\n          'Stack': STACK_NAME,\n          'Region': region,\n          'Platform URL': platformUrl,\n          'Lambda': outputMap.LambdaFunctionArn || LAMBDA_NAME,\n          'Event Queue': outputMap.EventQueueUrl || '(see AWS console)',\n          'Dead Letter Queue': outputMap.DeadLetterQueueUrl || '(see AWS console)',\n          'EventBridge Rule': outputMap.EventRuleName || '(see AWS console)',\n          'Status': '✓ Deployed',\n        });\n\n        console.log('');\n        printSuccess('EventBridge event ingestion is active.');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'setup-events', executionId, stack: STACK_NAME },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/status.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+/**
+ * Registers the `status` command with the CLI program.
+ *
+ * Checks environment variables, CDK availability, platform connectivity,
+ * and token expiry to give a quick overview of the current setup.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function status(program: Command): void;
+//# sourceMappingURL=status.d.ts.map

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

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

package/dist/commands/status.js

@@ -0,0 +1,89 @@
+"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.status = status;
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const cli_constants_1 = require("../config/cli.constants");
+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");
+/**
+ * Registers the `status` command with the CLI program.
+ *
+ * Checks environment variables, CDK availability, platform connectivity,
+ * and token expiry to give a quick overview of the current setup.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+function status(program) {
+    program
+        .command('status')
+        .description('Show environment and connectivity status')
+        .option('--json', 'Output result as JSON', false)
+        .action(async (options) => {
+        const executionId = (0, command_utils_1.printCommandHeader)('Status');
+        try {
+            const results = {};
+            // 1. Check PLATFORM_TOKEN
+            const token = process.env[cli_constants_1.ENV_VARS.PLATFORM_TOKEN];
+            results.PLATFORM_TOKEN = token ? 'set' : 'not set';
+            // 2. Check PLATFORM_SECRET_NAME
+            const secretName = process.env.PLATFORM_SECRET_NAME;
+            results.PLATFORM_SECRET_NAME = secretName || 'not set';
+            // 3. Check CDK availability
+            results['CDK Available'] = (0, cdk_utils_1.checkCdkAvailable)() ? 'yes' : 'no';
+            // 4. Check platform health
+            const baseUrl = process.env[cli_constants_1.ENV_VARS.PLATFORM_BASE_URL] || 'https://localhost:8443';
+            results.PLATFORM_BASE_URL = baseUrl;
+            try {
+                const httpsAgent = new https_1.default.Agent({ rejectUnauthorized: false });
+                await axios_1.default.get(`${baseUrl}/health`, {
+                    timeout: cli_constants_1.TIMEOUTS.HEALTH_CHECK,
+                    httpsAgent,
+                });
+                results['Platform Health'] = 'reachable';
+            }
+            catch {
+                results['Platform Health'] = 'unreachable';
+            }
+            // 5. Decode token expiry
+            if (token) {
+                try {
+                    const parts = token.split('.');
+                    if (parts.length === 3 && parts[1]) {
+                        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+                        if (typeof payload.exp === 'number') {
+                            const expiresAt = new Date(payload.exp * 1000);
+                            results['Token Expires'] = expiresAt.toISOString();
+                            results['Token Expired'] = expiresAt.getTime() < Date.now() ? 'yes' : 'no';
+                        }
+                    }
+                }
+                catch {
+                    results['Token Expires'] = 'unable to decode';
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));
+            }
+            else {
+                (0, output_utils_1.printSection)('Environment Status');
+                (0, output_utils_1.printKeyValue)(results);
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'status', executionId },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport { ENV_VARS, TIMEOUTS } from '../config/cli.constants';\nimport { checkCdkAvailable } from '../utils/cdk-utils';\nimport { printCommandHeader } from '../utils/command-utils';\nimport { ERROR_CODES, handleError } from '../utils/error-handler';\nimport { printKeyValue, printSection } from '../utils/output-utils';\n\n/**\n * Registers the `status` command with the CLI program.\n *\n * Checks environment variables, CDK availability, platform connectivity,\n * and token expiry to give a quick overview of the current setup.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function status(program: Command): void {\n  program\n    .command('status')\n    .description('Show environment and connectivity status')\n    .option('--json', 'Output result as JSON', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Status');\n\n      try {\n        const results: Record<string, string> = {};\n\n        // 1. Check PLATFORM_TOKEN\n        const token = process.env[ENV_VARS.PLATFORM_TOKEN];\n        results.PLATFORM_TOKEN = token ? 'set' : 'not set';\n\n        // 2. Check PLATFORM_SECRET_NAME\n        const secretName = process.env.PLATFORM_SECRET_NAME;\n        results.PLATFORM_SECRET_NAME = secretName || 'not set';\n\n        // 3. Check CDK availability\n        results['CDK Available'] = checkCdkAvailable() ? 'yes' : 'no';\n\n        // 4. Check platform health\n        const baseUrl = process.env[ENV_VARS.PLATFORM_BASE_URL] || 'https://localhost:8443';\n        results.PLATFORM_BASE_URL = baseUrl;\n\n        try {\n          const httpsAgent = new https.Agent({ rejectUnauthorized: false });\n          await axios.get(`${baseUrl}/health`, {\n            timeout: TIMEOUTS.HEALTH_CHECK,\n            httpsAgent,\n          });\n          results['Platform Health'] = 'reachable';\n        } catch {\n          results['Platform Health'] = 'unreachable';\n        }\n\n        // 5. Decode token expiry\n        if (token) {\n          try {\n            const parts = token.split('.');\n            if (parts.length === 3 && parts[1]) {\n              const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8')) as Record<string, unknown>;\n              if (typeof payload.exp === 'number') {\n                const expiresAt = new Date(payload.exp * 1000);\n                results['Token Expires'] = expiresAt.toISOString();\n                results['Token Expired'] = expiresAt.getTime() < Date.now() ? 'yes' : 'no';\n              }\n            }\n          } catch {\n            results['Token Expires'] = 'unable to decode';\n          }\n        }\n\n        if (options.json) {\n          console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));\n        } else {\n          printSection('Environment Status');\n          printKeyValue(results);\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'status', executionId },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/store-token.d.ts

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

package/dist/commands/store-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-token.d.ts","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmLjD"}