@pipeline-builder/pipeline-manager 3.1.0

package/dist/cli.d.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * CLI initialization options
+ */
+interface CliOptions {
+    /**
+     * Show banner on startup
+     * @default true
+     */
+    showBanner?: boolean;
+    /**
+     * Minimal banner (no ASCII art)
+     * @default false
+     */
+    minimalBanner?: boolean;
+    /**
+     * Debug mode
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Verbose output
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Quiet mode (minimal output)
+     * @default false
+     */
+    quiet?: boolean;
+    /**
+     * No color output
+     * @default false
+     */
+    noColor?: boolean;
+}
+/**
+ * Initialize CLI with options
+ *
+ * @param options - CLI initialization options
+ */
+export declare function initializeCli(options?: CliOptions): void;
+/**
+ * Main CLI entry point
+ *
+ * @param options - CLI initialization options
+ *
+ * @example
+ * ```typescript
+ * // Standard initialization
+ * main();
+ *
+ * // Minimal mode
+ * main({ minimalBanner: true, quiet: true });
+ *
+ * // Debug mode
+ * main({ debug: true, verbose: true });
+ * ```
+ */
+export declare function main(options?: CliOptions): void;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA+BA;;GAEG;AACH,UAAU,UAAU;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AA4ND;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CAyD5D;AAiDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,UAAe,GAAG,IAAI,CA0BnD"}

package/dist/cli.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCli = initializeCli;
+exports.main = main;
+const commander_1 = require("commander");
+const bootstrap_1 = require("./commands/bootstrap");
+const create_pipeline_1 = require("./commands/create-pipeline");
+const deploy_1 = require("./commands/deploy");
+const get_pipeline_1 = require("./commands/get-pipeline");
+const get_plugin_1 = require("./commands/get-plugin");
+const list_pipelines_1 = require("./commands/list-pipelines");
+const list_plugins_1 = require("./commands/list-plugins");
+const login_1 = require("./commands/login");
+const setup_events_1 = require("./commands/setup-events");
+const status_1 = require("./commands/status");
+const store_token_1 = require("./commands/store-token");
+const synth_1 = require("./commands/synth");
+const upload_plugin_1 = require("./commands/upload-plugin");
+const version_1 = require("./commands/version");
+const cli_constants_1 = require("./config/cli.constants");
+const banner_1 = require("./utils/banner");
+const error_handler_1 = require("./utils/error-handler");
+const output_utils_1 = require("./utils/output-utils");
+/**
+ * Check environment and display warnings
+ */
+function checkEnvironment() {
+    const warnings = [];
+    // Check for required environment variables
+    if (!process.env[cli_constants_1.ENV_VARS.PLATFORM_TOKEN]) {
+        warnings.push('PLATFORM_TOKEN environment variable is not set');
+        warnings.push('Authentication will fail for API operations');
+    }
+    // Check Node version
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0] || '0', 10);
+    if (majorVersion < 18) {
+        warnings.push(`Node.js ${nodeVersion} detected - version 18+ recommended`);
+    }
+    // Display warnings
+    if (warnings.length > 0) {
+        (0, output_utils_1.printSection)('Environment Warnings');
+        warnings.forEach(warning => {
+            (0, output_utils_1.printWarning)(warning);
+        });
+        console.log('');
+    }
+}
+/**
+ * Display startup information
+ */
+function displayStartupInfo(options) {
+    if (options.quiet)
+        return;
+    const executionId = (0, cli_constants_1.generateExecutionId)();
+    if (options.debug || options.verbose) {
+        (0, output_utils_1.printDebug)('CLI Configuration', {
+            name: cli_constants_1.APP_NAME,
+            version: cli_constants_1.APP_VERSION,
+            executionId,
+            node: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            cwd: process.cwd(),
+            env: {
+                debug: process.env.DEBUG,
+                token: process.env[cli_constants_1.ENV_VARS.PLATFORM_TOKEN] ? 'set' : 'not set',
+                url: process.env[cli_constants_1.ENV_VARS.PLATFORM_BASE_URL] || 'default',
+            },
+        });
+    }
+    else {
+        (0, output_utils_1.printDebug)('Starting CLI', {
+            version: cli_constants_1.APP_VERSION,
+            executionId,
+        });
+    }
+}
+/**
+ * Register all CLI commands
+ */
+function registerCommands() {
+    (0, output_utils_1.printDebug)('Registering commands');
+    // Configure program
+    commander_1.program
+        .name(cli_constants_1.APP_NAME)
+        .description(cli_constants_1.APP_DESCRIPTION)
+        .version(cli_constants_1.APP_VERSION, '-v, --version', 'Show CLI version')
+        .option('--debug', 'Enable debug output with stack traces', false)
+        .option('--verbose', 'Show detailed information', false)
+        .option('--quiet', 'Minimal output (errors only)', false)
+        .option('--no-color', 'Disable colored output', false)
+        .addHelpText('after', `
+Environment Variables:
+  ${cli_constants_1.ENV_VARS.PLATFORM_TOKEN}              Authentication token (required)
+  ${cli_constants_1.ENV_VARS.PLATFORM_BASE_URL}                 API base URL (optional)
+  ${cli_constants_1.ENV_VARS.CLI_CONFIG_PATH}              Config file path (optional)
+  ${cli_constants_1.ENV_VARS.TLS_REJECT_UNAUTHORIZED}      Disable SSL verification if '0'
+  ${cli_constants_1.ENV_VARS.DEBUG}                        Enable debug mode if 'true'
+
+Examples:
+  $ ${cli_constants_1.APP_NAME} version
+  $ ${cli_constants_1.APP_NAME} list-pipelines --project my-app
+  $ ${cli_constants_1.APP_NAME} get-pipeline --id pipe-123 --format json
+  $ ${cli_constants_1.APP_NAME} store-token --days 30 --region us-east-1
+  $ ${cli_constants_1.APP_NAME} bootstrap --account 123456789012 --region us-east-1
+  $ ${cli_constants_1.APP_NAME} deploy --id pipe-123 --profile production
+
+`);
+    // Version command (special handling)
+    (0, version_1.version)(commander_1.program);
+    // Authentication commands
+    (0, output_utils_1.printDebug)('Registering authentication commands');
+    (0, login_1.login)(commander_1.program); // Login and obtain PLATFORM_TOKEN (also supports --refresh)
+    // Query commands
+    (0, output_utils_1.printDebug)('Registering query commands');
+    (0, get_plugin_1.getPlugin)(commander_1.program); // Single plugin by ID
+    (0, list_plugins_1.listPlugins)(commander_1.program); // Multiple plugins with filters
+    (0, get_pipeline_1.getPipeline)(commander_1.program); // Single pipeline by ID
+    (0, list_pipelines_1.listPipelines)(commander_1.program); // Multiple pipelines with filters
+    // Create/Upload commands
+    (0, output_utils_1.printDebug)('Registering create/upload commands');
+    (0, create_pipeline_1.createPipeline)(commander_1.program); // Create pipeline configuration
+    (0, upload_plugin_1.uploadPlugin)(commander_1.program); // Upload and deploy plugin
+    // Status command
+    (0, output_utils_1.printDebug)('Registering status command');
+    (0, status_1.status)(commander_1.program); // Show environment and connectivity status
+    // Deployment commands
+    (0, output_utils_1.printDebug)('Registering deployment commands');
+    (0, store_token_1.storeToken)(commander_1.program); // Generate JWT token and store in Secrets Manager
+    (0, setup_events_1.setupEvents)(commander_1.program); // Deploy EventBridge event ingestion infrastructure
+    (0, bootstrap_1.bootstrap)(commander_1.program); // Bootstrap CDK toolkit stack
+    (0, deploy_1.deploy)(commander_1.program); // Deploy pipeline with CDK (--app prints boilerplate path)
+    (0, synth_1.synth)(commander_1.program); // Run CDK synthesis
+    // Shell completions
+    (0, output_utils_1.printDebug)('Registering completions command');
+    commander_1.program
+        .command('completions')
+        .description('Generate shell completions (bash, zsh, fish)')
+        .argument('<shell>', 'Shell type: bash, zsh, or fish')
+        .action((shell) => {
+        switch (shell) {
+            case 'bash':
+                console.log(`# pipeline-manager bash completions
+_pipeline_manager_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions"
+  COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+}
+complete -F _pipeline_manager_completions pipeline-manager`);
+                break;
+            case 'zsh':
+                console.log(`# pipeline-manager zsh completions
+_pipeline_manager() {
+  local commands=(login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions)
+  _describe 'command' commands
+}
+compdef _pipeline_manager pipeline-manager`);
+                break;
+            case 'fish':
+                console.log(`# pipeline-manager fish completions
+complete -c pipeline-manager -n '__fish_use_subcommand' -a 'login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions'`);
+                break;
+            default:
+                console.error(`Unknown shell: ${shell}. Use bash, zsh, or fish.`);
+                process.exit(1);
+        }
+    });
+    (0, output_utils_1.printDebug)('All commands registered successfully');
+}
+/**
+ * Handle program errors
+ */
+function setupErrorHandlers() {
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        console.error(''); // Empty line
+        (0, output_utils_1.printError)('Uncaught exception', {
+            error: error.message,
+            name: error.name,
+        });
+        (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+            debug: (0, cli_constants_1.isDebugMode)(commander_1.program.opts()),
+            exit: true,
+            context: {
+                type: 'uncaughtException',
+            },
+        });
+    });
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason) => {
+        console.error(''); // Empty line
+        (0, output_utils_1.printError)('Unhandled promise rejection', {
+            reason: reason instanceof Error ? reason.message : String(reason),
+        });
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+            debug: (0, cli_constants_1.isDebugMode)(commander_1.program.opts()),
+            exit: true,
+            context: {
+                type: 'unhandledRejection',
+            },
+        });
+    });
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+        console.log(''); // Empty line
+        (0, output_utils_1.printWarning)('Process interrupted by user (SIGINT)');
+        console.log(''); // Empty line
+        process.exit(130); // Standard exit code for SIGINT
+    });
+    // Handle SIGTERM
+    process.on('SIGTERM', () => {
+        console.log(''); // Empty line
+        (0, output_utils_1.printWarning)('Process terminated (SIGTERM)');
+        console.log(''); // Empty line
+        process.exit(143); // Standard exit code for SIGTERM
+    });
+}
+/**
+ * Initialize CLI with options
+ *
+ * @param options - CLI initialization options
+ */
+function initializeCli(options = {}) {
+    const { showBanner = true, minimalBanner = false, debug = false, verbose = false, quiet = false, noColor = false, } = options;
+    // Handle color output
+    if (noColor) {
+        process.env.NO_COLOR = '1';
+    }
+    // Display banner
+    if (showBanner && !quiet) {
+        if (minimalBanner) {
+            (0, banner_1.miniBanner)();
+        }
+        else {
+            (0, banner_1.banner)({
+                minimal: false,
+                showDescription: true,
+                showTimestamp: debug || verbose,
+                showExecutionId: debug,
+            });
+        }
+    }
+    // Display startup info
+    displayStartupInfo({ debug, verbose, quiet });
+    // Check environment
+    if (!quiet) {
+        checkEnvironment();
+    }
+    // Setup error handlers
+    setupErrorHandlers();
+    // Register commands
+    try {
+        registerCommands();
+        (0, output_utils_1.printDebug)('CLI initialization complete');
+    }
+    catch (error) {
+        (0, output_utils_1.printError)('CLI initialization failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.CONFIGURATION, {
+            debug: debug || (0, cli_constants_1.isDebugMode)(),
+            exit: true,
+            context: {
+                stage: 'initialization',
+            },
+        });
+    }
+}
+/**
+ * Parse command line arguments
+ */
+function parseArguments() {
+    try {
+        commander_1.program.parse(process.argv);
+        // Show help if no command provided
+        const args = process.argv.slice(2);
+        if (args.length === 0) {
+            (0, output_utils_1.printInfo)('No command specified - displaying help');
+            console.log(''); // Empty line
+            commander_1.program.outputHelp();
+            process.exit(0);
+        }
+        // Check if command exists
+        const command = args[0];
+        if (command && !command.startsWith('-')) {
+            const commandExists = commander_1.program.commands.some(cmd => cmd.name() === command);
+            if (!commandExists) {
+                console.log(''); // Empty line
+                (0, output_utils_1.printError)(`Unknown command: ${command}`);
+                console.log(''); // Empty line
+                (0, output_utils_1.printInfo)('Available commands:');
+                commander_1.program.commands.forEach(cmd => {
+                    console.log(`  • ${cmd.name()} - ${cmd.description()}`);
+                });
+                console.log(''); // Empty line
+                process.exit(1);
+            }
+        }
+        (0, output_utils_1.printDebug)('Command line arguments parsed successfully');
+    }
+    catch (error) {
+        (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+            debug: (0, cli_constants_1.isDebugMode)(commander_1.program.opts()),
+            exit: true,
+            context: {
+                stage: 'argument-parsing',
+                argv: process.argv,
+            },
+        });
+    }
+}
+/**
+ * Main CLI entry point
+ *
+ * @param options - CLI initialization options
+ *
+ * @example
+ * ```typescript
+ * // Standard initialization
+ * main();
+ *
+ * // Minimal mode
+ * main({ minimalBanner: true, quiet: true });
+ *
+ * // Debug mode
+ * main({ debug: true, verbose: true });
+ * ```
+ */
+function main(options = {}) {
+    try {
+        // Initialize CLI
+        initializeCli(options);
+        // Parse arguments and execute command
+        parseArguments();
+        // If we reach here, command completed successfully
+        (0, output_utils_1.printDebug)('CLI execution completed successfully');
+    }
+    catch (error) {
+        // Final catch-all error handler
+        console.error(''); // Empty line
+        (0, output_utils_1.printError)('Fatal CLI error', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        (0, error_handler_1.handleError)(error, error_handler_1.ERROR_CODES.GENERAL, {
+            debug: (0, cli_constants_1.isDebugMode)(options),
+            exit: true,
+            context: {
+                stage: 'main',
+                options,
+            },
+        });
+    }
+}
+/**
+ * Run CLI if executed directly
+ */
+if (require.main === module) {
+    // Parse CLI options from environment or command line
+    const options = {
+        debug: process.env.DEBUG === 'true',
+        quiet: process.argv.includes('--quiet'),
+        verbose: process.argv.includes('--verbose'),
+        noColor: process.argv.includes('--no-color') || process.env.NO_COLOR === '1',
+    };
+    main(options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { program } from 'commander';\nimport { bootstrap } from './commands/bootstrap';\nimport { createPipeline } from './commands/create-pipeline';\nimport { deploy } from './commands/deploy';\nimport { getPipeline } from './commands/get-pipeline';\nimport { getPlugin } from './commands/get-plugin';\nimport { listPipelines } from './commands/list-pipelines';\nimport { listPlugins } from './commands/list-plugins';\nimport { login } from './commands/login';\nimport { setupEvents } from './commands/setup-events';\nimport { status } from './commands/status';\nimport { storeToken } from './commands/store-token';\nimport { synth } from './commands/synth';\nimport { uploadPlugin } from './commands/upload-plugin';\nimport { version } from './commands/version';\nimport {\n  APP_NAME,\n  APP_DESCRIPTION,\n  APP_VERSION,\n  ENV_VARS,\n  isDebugMode,\n  generateExecutionId,\n} from './config/cli.constants';\nimport { banner, miniBanner } from './utils/banner';\nimport { ERROR_CODES, handleError } from './utils/error-handler';\nimport { printInfo, printError, printWarning, printDebug, printSection } from './utils/output-utils';\n\n/**\n * CLI initialization options\n */\ninterface CliOptions {\n  /**\n   * Show banner on startup\n   * @default true\n   */\n  showBanner?: boolean;\n\n  /**\n   * Minimal banner (no ASCII art)\n   * @default false\n   */\n  minimalBanner?: boolean;\n\n  /**\n   * Debug mode\n   * @default false\n   */\n  debug?: boolean;\n\n  /**\n   * Verbose output\n   * @default false\n   */\n  verbose?: boolean;\n\n  /**\n   * Quiet mode (minimal output)\n   * @default false\n   */\n  quiet?: boolean;\n\n  /**\n   * No color output\n   * @default false\n   */\n  noColor?: boolean;\n}\n\n/**\n * Check environment and display warnings\n */\nfunction checkEnvironment(): void {\n  const warnings: string[] = [];\n\n  // Check for required environment variables\n  if (!process.env[ENV_VARS.PLATFORM_TOKEN]) {\n    warnings.push('PLATFORM_TOKEN environment variable is not set');\n    warnings.push('Authentication will fail for API operations');\n  }\n\n  // Check Node version\n  const nodeVersion = process.version;\n  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0] || '0', 10);\n  if (majorVersion < 18) {\n    warnings.push(`Node.js ${nodeVersion} detected - version 18+ recommended`);\n  }\n\n  // Display warnings\n  if (warnings.length > 0) {\n    printSection('Environment Warnings');\n    warnings.forEach(warning => {\n      printWarning(warning);\n    });\n    console.log('');\n  }\n}\n\n/**\n * Display startup information\n */\nfunction displayStartupInfo(options: CliOptions): void {\n  if (options.quiet) return;\n\n  const executionId = generateExecutionId();\n\n  if (options.debug || options.verbose) {\n    printDebug('CLI Configuration', {\n      name: APP_NAME,\n      version: APP_VERSION,\n      executionId,\n      node: process.version,\n      platform: process.platform,\n      arch: process.arch,\n      cwd: process.cwd(),\n      env: {\n        debug: process.env.DEBUG,\n        token: process.env[ENV_VARS.PLATFORM_TOKEN] ? 'set' : 'not set',\n        url: process.env[ENV_VARS.PLATFORM_BASE_URL] || 'default',\n      },\n    });\n  } else {\n    printDebug('Starting CLI', {\n      version: APP_VERSION,\n      executionId,\n    });\n  }\n}\n\n/**\n * Register all CLI commands\n */\nfunction registerCommands(): void {\n  printDebug('Registering commands');\n\n  // Configure program\n  program\n    .name(APP_NAME)\n    .description(APP_DESCRIPTION)\n    .version(APP_VERSION, '-v, --version', 'Show CLI version')\n    .option('--debug', 'Enable debug output with stack traces', false)\n    .option('--verbose', 'Show detailed information', false)\n    .option('--quiet', 'Minimal output (errors only)', false)\n    .option('--no-color', 'Disable colored output', false)\n    .addHelpText('after', `\nEnvironment Variables:\n  ${ENV_VARS.PLATFORM_TOKEN}              Authentication token (required)\n  ${ENV_VARS.PLATFORM_BASE_URL}                 API base URL (optional)\n  ${ENV_VARS.CLI_CONFIG_PATH}              Config file path (optional)\n  ${ENV_VARS.TLS_REJECT_UNAUTHORIZED}      Disable SSL verification if '0'\n  ${ENV_VARS.DEBUG}                        Enable debug mode if 'true'\n\nExamples:\n  $ ${APP_NAME} version\n  $ ${APP_NAME} list-pipelines --project my-app\n  $ ${APP_NAME} get-pipeline --id pipe-123 --format json\n  $ ${APP_NAME} store-token --days 30 --region us-east-1\n  $ ${APP_NAME} bootstrap --account 123456789012 --region us-east-1\n  $ ${APP_NAME} deploy --id pipe-123 --profile production\n\n`);\n\n  // Version command (special handling)\n  version(program);\n\n  // Authentication commands\n  printDebug('Registering authentication commands');\n  login(program); // Login and obtain PLATFORM_TOKEN (also supports --refresh)\n\n  // Query commands\n  printDebug('Registering query commands');\n  getPlugin(program); // Single plugin by ID\n  listPlugins(program); // Multiple plugins with filters\n  getPipeline(program); // Single pipeline by ID\n  listPipelines(program); // Multiple pipelines with filters\n\n  // Create/Upload commands\n  printDebug('Registering create/upload commands');\n  createPipeline(program); // Create pipeline configuration\n  uploadPlugin(program); // Upload and deploy plugin\n\n  // Status command\n  printDebug('Registering status command');\n  status(program); // Show environment and connectivity status\n\n  // Deployment commands\n  printDebug('Registering deployment commands');\n  storeToken(program); // Generate JWT token and store in Secrets Manager\n  setupEvents(program); // Deploy EventBridge event ingestion infrastructure\n  bootstrap(program); // Bootstrap CDK toolkit stack\n  deploy(program); // Deploy pipeline with CDK (--app prints boilerplate path)\n  synth(program); // Run CDK synthesis\n\n  // Shell completions\n  printDebug('Registering completions command');\n  program\n    .command('completions')\n    .description('Generate shell completions (bash, zsh, fish)')\n    .argument('<shell>', 'Shell type: bash, zsh, or fish')\n    .action((shell: string) => {\n      switch (shell) {\n        case 'bash':\n          console.log(`# pipeline-manager bash completions\n_pipeline_manager_completions() {\n  local cur=\"\\${COMP_WORDS[COMP_CWORD]}\"\n  local commands=\"login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions\"\n  COMPREPLY=($(compgen -W \"\\${commands}\" -- \"\\${cur}\"))\n}\ncomplete -F _pipeline_manager_completions pipeline-manager`);\n          break;\n        case 'zsh':\n          console.log(`# pipeline-manager zsh completions\n_pipeline_manager() {\n  local commands=(login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions)\n  _describe 'command' commands\n}\ncompdef _pipeline_manager pipeline-manager`);\n          break;\n        case 'fish':\n          console.log(`# pipeline-manager fish completions\ncomplete -c pipeline-manager -n '__fish_use_subcommand' -a 'login deploy synth upload-plugin create-pipeline status version bootstrap setup-events store-token completions'`);\n          break;\n        default:\n          console.error(`Unknown shell: ${shell}. Use bash, zsh, or fish.`);\n          process.exit(1);\n      }\n    });\n\n  printDebug('All commands registered successfully');\n}\n\n/**\n * Handle program errors\n */\nfunction setupErrorHandlers(): void {\n  // Handle uncaught exceptions\n  process.on('uncaughtException', (error: Error) => {\n    console.error(''); // Empty line\n    printError('Uncaught exception', {\n      error: error.message,\n      name: error.name,\n    });\n\n    handleError(error, ERROR_CODES.GENERAL, {\n      debug: isDebugMode(program.opts()),\n      exit: true,\n      context: {\n        type: 'uncaughtException',\n      },\n    });\n  });\n\n  // Handle unhandled promise rejections\n  process.on('unhandledRejection', (reason: unknown) => {\n    console.error(''); // Empty line\n    printError('Unhandled promise rejection', {\n      reason: reason instanceof Error ? reason.message : String(reason),\n    });\n\n    const error = reason instanceof Error ? reason : new Error(String(reason));\n\n    handleError(error, ERROR_CODES.GENERAL, {\n      debug: isDebugMode(program.opts()),\n      exit: true,\n      context: {\n        type: 'unhandledRejection',\n      },\n    });\n  });\n\n  // Handle SIGINT (Ctrl+C)\n  process.on('SIGINT', () => {\n    console.log(''); // Empty line\n    printWarning('Process interrupted by user (SIGINT)');\n    console.log(''); // Empty line\n    process.exit(130); // Standard exit code for SIGINT\n  });\n\n  // Handle SIGTERM\n  process.on('SIGTERM', () => {\n    console.log(''); // Empty line\n    printWarning('Process terminated (SIGTERM)');\n    console.log(''); // Empty line\n    process.exit(143); // Standard exit code for SIGTERM\n  });\n}\n\n/**\n * Initialize CLI with options\n *\n * @param options - CLI initialization options\n */\nexport function initializeCli(options: CliOptions = {}): void {\n  const {\n    showBanner = true,\n    minimalBanner = false,\n    debug = false,\n    verbose = false,\n    quiet = false,\n    noColor = false,\n  } = options;\n\n  // Handle color output\n  if (noColor) {\n    process.env.NO_COLOR = '1';\n  }\n\n  // Display banner\n  if (showBanner && !quiet) {\n    if (minimalBanner) {\n      miniBanner();\n    } else {\n      banner({\n        minimal: false,\n        showDescription: true,\n        showTimestamp: debug || verbose,\n        showExecutionId: debug,\n      });\n    }\n  }\n\n  // Display startup info\n  displayStartupInfo({ debug, verbose, quiet });\n\n  // Check environment\n  if (!quiet) {\n    checkEnvironment();\n  }\n\n  // Setup error handlers\n  setupErrorHandlers();\n\n  // Register commands\n  try {\n    registerCommands();\n    printDebug('CLI initialization complete');\n  } catch (error) {\n    printError('CLI initialization failed', {\n      error: error instanceof Error ? error.message : String(error),\n    });\n\n    handleError(error, ERROR_CODES.CONFIGURATION, {\n      debug: debug || isDebugMode(),\n      exit: true,\n      context: {\n        stage: 'initialization',\n      },\n    });\n  }\n}\n\n/**\n * Parse command line arguments\n */\nfunction parseArguments(): void {\n  try {\n    program.parse(process.argv);\n\n    // Show help if no command provided\n    const args = process.argv.slice(2);\n    if (args.length === 0) {\n      printInfo('No command specified - displaying help');\n      console.log(''); // Empty line\n      program.outputHelp();\n      process.exit(0);\n    }\n\n    // Check if command exists\n    const command = args[0];\n    if (command && !command.startsWith('-')) {\n      const commandExists = program.commands.some(cmd => cmd.name() === command);\n\n      if (!commandExists) {\n        console.log(''); // Empty line\n        printError(`Unknown command: ${command}`);\n        console.log(''); // Empty line\n        printInfo('Available commands:');\n        program.commands.forEach(cmd => {\n          console.log(`  • ${cmd.name()} - ${cmd.description()}`);\n        });\n        console.log(''); // Empty line\n        process.exit(1);\n      }\n    }\n\n    printDebug('Command line arguments parsed successfully');\n  } catch (error) {\n    handleError(error, ERROR_CODES.GENERAL, {\n      debug: isDebugMode(program.opts()),\n      exit: true,\n      context: {\n        stage: 'argument-parsing',\n        argv: process.argv,\n      },\n    });\n  }\n}\n\n/**\n * Main CLI entry point\n *\n * @param options - CLI initialization options\n *\n * @example\n * ```typescript\n * // Standard initialization\n * main();\n *\n * // Minimal mode\n * main({ minimalBanner: true, quiet: true });\n *\n * // Debug mode\n * main({ debug: true, verbose: true });\n * ```\n */\nexport function main(options: CliOptions = {}): void {\n  try {\n    // Initialize CLI\n    initializeCli(options);\n\n    // Parse arguments and execute command\n    parseArguments();\n\n    // If we reach here, command completed successfully\n    printDebug('CLI execution completed successfully');\n  } catch (error) {\n    // Final catch-all error handler\n    console.error(''); // Empty line\n    printError('Fatal CLI error', {\n      error: error instanceof Error ? error.message : String(error),\n    });\n\n    handleError(error, ERROR_CODES.GENERAL, {\n      debug: isDebugMode(options),\n      exit: true,\n      context: {\n        stage: 'main',\n        options,\n      },\n    });\n  }\n}\n\n/**\n * Run CLI if executed directly\n */\nif (require.main === module) {\n  // Parse CLI options from environment or command line\n  const options: CliOptions = {\n    debug: process.env.DEBUG === 'true',\n    quiet: process.argv.includes('--quiet'),\n    verbose: process.argv.includes('--verbose'),\n    noColor: process.argv.includes('--no-color') || process.env.NO_COLOR === '1',\n  };\n\n  main(options);\n}"]}

package/dist/commands/bootstrap.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+/**
+ * Registers the `bootstrap` command with the CLI program.
+ *
+ * Provisions the CDK toolkit stack in the target AWS account/region
+ * so that CDK deployments can proceed.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function bootstrap(program: Command): void;
+//# sourceMappingURL=bootstrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/commands/bootstrap.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsEpC;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+FhD"}