@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/setup-events.js

@@ -0,0 +1,168 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import * as os from 'os';
+import path from 'path';
+import { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
+import { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';
+import { Command } from 'commander';
+import { EVENTS_STACK_NAME } from '../config/cli.constants.js';
+import { applyAwsProfile, resolveAwsRegion } from '../utils/aws-env.js';
+import { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printError, printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';
+import { resolvePlatformSecretName } from '../utils/platform-secret.js';
+// ESM has no __dirname; derive it from this module's URL.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STACK_NAME = EVENTS_STACK_NAME;
+// 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/pipeline-events';
+/**
+ * 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/pipeline-events 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 function setupEvents(program) {
+    withProfileOption(withRegionOption(program
+        .command('setup-events')
+        .description('Deploy EventBridge event ingestion infrastructure for pipeline reporting')
+        .option('--package-version <version>', 'pipeline-events package version (default: latest)')
+        .option('-u, --identifier <identifier>', 'Username or email to mint a token when PLATFORM_TOKEN is unset (for deriving the secret name)')
+        .option('-p, --password <password>', 'Login password (used with --identifier)')))
+        .option('--scoped-ingest', 'Point the ingestion Lambda at the dedicated least-privilege reporting-ingest secret (provision it first: `store-token --scope reporting:ingest --schedule`). The reporting service always requires the `reporting:ingest` scope on POST /reports/events.')
+        .option('--with-dora', 'Enable DORA lead-time enrichment in the ingestion Lambda: it resolves commit timestamps in-account (CodeCommit / the org github-token secret / CodeConnections). Off by default — extra SCM/secret cost. Enable only for orgs with the advanced_reporting add-on; re-run setup-events to toggle after purchase.')
+        .action(async (options) => {
+        const executionId = printCommandHeader('Setup Event Ingestion');
+        try {
+            const region = resolveAwsRegion(options.region);
+            // Honor --profile for the SDK Lambda/CloudFormation clients below. The
+            // `cloudformation deploy` CLI call already gets --profile; without this the
+            // SDK clients hit the DEFAULT account → deploy and code-update/outputs
+            // target different accounts (silent split-brain).
+            applyAwsProfile(options.profile);
+            const platformUrl = process.env.PLATFORM_BASE_URL;
+            if (!platformUrl) {
+                printError('PLATFORM_BASE_URL environment variable is required');
+                throw new Error('PLATFORM_BASE_URL not set');
+            }
+            // Derive the secret path from the platform token (the one init-platform.sh
+            // minted) when PLATFORM_SECRET_NAME isn't set — matching store-token, which
+            // WROTE the secret at the same derived path. Logs in with
+            // --email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD if no token yet.
+            // With --scoped-ingest, point at the dedicated reporting-ingest secret
+            // (a least-privilege machine credential) instead of the shared platform
+            // token — provision it with `store-token --scope reporting:ingest`.
+            let secretName = await resolvePlatformSecretName(options);
+            if (options.scopedIngest) {
+                secretName = secretName.replace(/\/platform$/, '/reporting-ingest');
+            }
+            printInfo('Parameters', {
+                stack: STACK_NAME,
+                region,
+                platformUrl,
+                secretName,
+                packageVersion: options.packageVersion || 'latest',
+                dora: options.withDora ? 'enabled (commit enrichment)' : 'disabled',
+            });
+            // Step 1: Deploy CloudFormation (infra only — Lambda gets placeholder code)
+            printSection('Deploy Infrastructure');
+            const templatePath = path.join(__dirname, '../templates/events-stack.json');
+            const cfnArgs = [
+                'cloudformation', 'deploy',
+                '--stack-name', STACK_NAME,
+                '--template-file', templatePath,
+                '--parameter-overrides',
+                `PlatformBaseUrl=${platformUrl}`,
+                `PlatformSecretName=${secretName}`,
+                `DoraEnabled=${options.withDora ? 'true' : 'false'}`,
+                '--capabilities', 'CAPABILITY_NAMED_IAM',
+                '--no-fail-on-empty-changeset',
+                '--region', region,
+            ];
+            if (options.profile)
+                cfnArgs.push('--profile', options.profile);
+            execFileSync('aws', cfnArgs, { stdio: 'inherit' });
+            printSuccess('Infrastructure deployed');
+            // Step 2: Download handler from registry and upload to Lambda
+            printSection('Deploy Lambda Code');
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'event-ingestion-'));
+            try {
+                const versionSpec = options.packageVersion ? `${PACKAGE_NAME}@${options.packageVersion}` : PACKAGE_NAME;
+                printInfo('Installing from registry', { package: versionSpec });
+                // Isolate the npm cache inside the temp dir so the deploy never depends on
+                // (or trips over) a misconfigured shared ~/.npm cache — e.g. EACCES/EEXIST
+                // left behind by a prior `sudo npm` run. Mirrors the token-renew handler.
+                execFileSync('npm', ['install', '--prefix', tmpDir, '--no-audit', '--no-fund', versionSpec], {
+                    stdio: 'pipe',
+                    env: { ...process.env, npm_config_cache: path.join(tmpDir, '.npm-cache') },
+                });
+                const handlerSrc = path.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.join(tmpDir, 'node_modules', PACKAGE_NAME, 'package.json');
+                const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                const version = pkgJson.version || 'unknown';
+                // pipeline-events is ESM ("type":"module"), so the Lambda entry must be
+                // index.mjs. A plain index.js with no package.json in the zip is loaded as
+                // CommonJS by nodejs24.x and fails at init with "Cannot use import statement
+                // outside a module". The .mjs extension forces ESM; Handler stays
+                // index.handler (the runtime resolves the .mjs file). lib/index.js is a
+                // self-contained bundle (no relative imports), so the single file suffices.
+                const mjsPath = path.join(tmpDir, 'index.mjs');
+                fs.copyFileSync(handlerSrc, mjsPath);
+                const zipPath = path.join(tmpDir, 'index.zip');
+                execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, stdio: 'pipe' });
+                // Upload directly to Lambda via SDK (no S3 needed)
+                printInfo('Uploading code to Lambda', { function: LAMBDA_NAME, version });
+                const lambdaClient = new LambdaClient({ region });
+                await lambdaClient.send(new UpdateFunctionCodeCommand({
+                    FunctionName: LAMBDA_NAME,
+                    ZipFile: fs.readFileSync(zipPath),
+                }));
+                printSuccess(`Lambda code deployed (${PACKAGE_NAME}@${version})`);
+            }
+            finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            // Step 3: Show outputs via SDK
+            const cfnClient = new CloudFormationClient({ region });
+            const describeResult = await cfnClient.send(new DescribeStacksCommand({ StackName: STACK_NAME }));
+            const outputs = describeResult.Stacks?.[0]?.Outputs ?? [];
+            const outputMap = Object.fromEntries(outputs.map(o => [o.OutputKey ?? '', o.OutputValue ?? '']));
+            console.log('');
+            printSection('Event Ingestion Ready');
+            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('');
+            printSuccess('EventBridge event ingestion is active.');
+        }
+        catch (error) {
+            handleError(error, 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 { fileURLToPath } from 'node:url';\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 { EVENTS_STACK_NAME } from '../config/cli.constants.js';\nimport { applyAwsProfile, resolveAwsRegion } from '../utils/aws-env.js';\nimport { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';\nimport { resolvePlatformSecretName } from '../utils/platform-secret.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nconst STACK_NAME = EVENTS_STACK_NAME;\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/pipeline-events';\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/pipeline-events 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  withProfileOption(\n    withRegionOption(program\n      .command('setup-events')\n      .description('Deploy EventBridge event ingestion infrastructure for pipeline reporting')\n      .option('--package-version <version>', 'pipeline-events package version (default: latest)')\n      .option('-u, --identifier <identifier>', 'Username or email to mint a token when PLATFORM_TOKEN is unset (for deriving the secret name)')\n      .option('-p, --password <password>', 'Login password (used with --identifier)')),\n  )\n    .option('--scoped-ingest', 'Point the ingestion Lambda at the dedicated least-privilege reporting-ingest secret (provision it first: `store-token --scope reporting:ingest --schedule`). The reporting service always requires the `reporting:ingest` scope on POST /reports/events.')\n    .option('--with-dora', 'Enable DORA lead-time enrichment in the ingestion Lambda: it resolves commit timestamps in-account (CodeCommit / the org github-token secret / CodeConnections). Off by default — extra SCM/secret cost. Enable only for orgs with the advanced_reporting add-on; re-run setup-events to toggle after purchase.')\n    .action(async (options) => {\n      const executionId = printCommandHeader('Setup Event Ingestion');\n\n      try {\n        const region = resolveAwsRegion(options.region);\n        // Honor --profile for the SDK Lambda/CloudFormation clients below. The\n        // `cloudformation deploy` CLI call already gets --profile; without this the\n        // SDK clients hit the DEFAULT account → deploy and code-update/outputs\n        // target different accounts (silent split-brain).\n        applyAwsProfile(options.profile);\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        // Derive the secret path from the platform token (the one init-platform.sh\n        // minted) when PLATFORM_SECRET_NAME isn't set — matching store-token, which\n        // WROTE the secret at the same derived path. Logs in with\n        // --email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD if no token yet.\n        // With --scoped-ingest, point at the dedicated reporting-ingest secret\n        // (a least-privilege machine credential) instead of the shared platform\n        // token — provision it with `store-token --scope reporting:ingest`.\n        let secretName = await resolvePlatformSecretName(options);\n        if (options.scopedIngest) {\n          secretName = secretName.replace(/\\/platform$/, '/reporting-ingest');\n        }\n\n        printInfo('Parameters', {\n          stack: STACK_NAME,\n          region,\n          platformUrl,\n          secretName,\n          packageVersion: options.packageVersion || 'latest',\n          dora: options.withDora ? 'enabled (commit enrichment)' : 'disabled',\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          `DoraEnabled=${options.withDora ? 'true' : 'false'}`,\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          // Isolate the npm cache inside the temp dir so the deploy never depends on\n          // (or trips over) a misconfigured shared ~/.npm cache — e.g. EACCES/EEXIST\n          // left behind by a prior `sudo npm` run. Mirrors the token-renew handler.\n          execFileSync('npm', ['install', '--prefix', tmpDir, '--no-audit', '--no-fund', versionSpec], {\n            stdio: 'pipe',\n            env: { ...process.env, npm_config_cache: path.join(tmpDir, '.npm-cache') },\n          });\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          // pipeline-events is ESM (\"type\":\"module\"), so the Lambda entry must be\n          // index.mjs. A plain index.js with no package.json in the zip is loaded as\n          // CommonJS by nodejs24.x and fails at init with \"Cannot use import statement\n          // outside a module\". The .mjs extension forces ESM; Handler stays\n          // index.handler (the runtime resolves the .mjs file). lib/index.js is a\n          // self-contained bundle (no relative imports), so the single file suffices.\n          const mjsPath = path.join(tmpDir, 'index.mjs');\n          fs.copyFileSync(handlerSrc, mjsPath);\n          const zipPath = path.join(tmpDir, 'index.zip');\n          execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, 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":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiE7C"}

package/dist/commands/status.js

@@ -0,0 +1,81 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import axios from 'axios';
+import { Command } from 'commander';
+import { ENV_VARS, TIMEOUTS } from '../config/cli.constants.js';
+import { decodeTokenPayload } from '../utils/auth-guard.js';
+import { checkCdkAvailable } from '../utils/cdk-utils.js';
+import { printCommandHeader } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printKeyValue, printSection } from '../utils/output-utils.js';
+import { httpsAgentForUrl } from '../utils/tls.js';
+/**
+ * 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 function status(program) {
+    program
+        .command('status')
+        .description('Show environment and connectivity status')
+        .option('--json', 'Output result as JSON', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Status', undefined, { quiet: options.json });
+        try {
+            const results = {};
+            // 1. Check PLATFORM_TOKEN
+            const token = process.env[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'] = checkCdkAvailable() ? 'yes' : 'no';
+            // 4. Check platform health
+            const baseUrl = process.env[ENV_VARS.PLATFORM_BASE_URL] || 'https://localhost:8443';
+            results.PLATFORM_BASE_URL = baseUrl;
+            try {
+                // Skip cert verification only for local/self-signed hosts; verify real domains.
+                await axios.get(`${baseUrl}/health`, {
+                    timeout: TIMEOUTS.HEALTH_CHECK,
+                    httpsAgent: httpsAgentForUrl(baseUrl),
+                });
+                results['Platform Health'] = 'reachable';
+            }
+            catch {
+                results['Platform Health'] = 'unreachable';
+            }
+            // 5. Decode token expiry (shared decoder — same base64url + exp logic
+            // used by audit-tokens / api-client).
+            if (token) {
+                const payload = decodeTokenPayload(token);
+                if (!payload) {
+                    results['Token Expires'] = 'unable to decode';
+                }
+                else 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';
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));
+            }
+            else {
+                printSection('Environment Status');
+                printKeyValue(results);
+            }
+        }
+        catch (error) {
+            handleError(error, 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 axios from 'axios';\nimport { Command } from 'commander';\nimport { ENV_VARS, TIMEOUTS } from '../config/cli.constants.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { checkCdkAvailable } from '../utils/cdk-utils.js';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printKeyValue, printSection } from '../utils/output-utils.js';\nimport { httpsAgentForUrl } from '../utils/tls.js';\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', undefined, { quiet: options.json });\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          // Skip cert verification only for local/self-signed hosts; verify real domains.\n          await axios.get(`${baseUrl}/health`, {\n            timeout: TIMEOUTS.HEALTH_CHECK,\n            httpsAgent: httpsAgentForUrl(baseUrl),\n          });\n          results['Platform Health'] = 'reachable';\n        } catch {\n          results['Platform Health'] = 'unreachable';\n        }\n\n        // 5. Decode token expiry (shared decoder — same base64url + exp logic\n        // used by audit-tokens / api-client).\n        if (token) {\n          const payload = decodeTokenPayload(token);\n          if (!payload) {\n            results['Token Expires'] = 'unable to decode';\n          } else 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\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,26 @@
+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.
+ *
+ * By default it ONLY writes the secret. Pass --schedule to also deploy the daily
+ * token-renewal stack (a Lambda that auto-renews this token before it expires).
+ *
+ * @example
+ * ```bash
+ * pipeline-manager infra store-token --region us-east-1
+ * pipeline-manager infra store-token --days 90 --region us-east-1
+ * pipeline-manager infra store-token --schedule --region us-east-1          # + daily auto-renewal
+ * pipeline-manager infra store-token --schedule --cron '0 3 * * *'          # custom renewal time
+ * pipeline-manager infra store-token --days 7 --no-verify-ssl
+ * PLATFORM_SECRET_NAME=my-custom-secret pipeline-manager infra store-token   # override the derived name
+ * pipeline-manager infra store-token --dry-run
+ * pipeline-manager infra 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":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyGpC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmNjD"}