@pipeline-builder/pipeline-manager 0.0.1

package/dist/cli.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { program } from 'commander';
+import { auditStacks } from './commands/audit-stacks.js';
+import { auditTokens } from './commands/audit-tokens.js';
+import { bootstrap } from './commands/bootstrap.js';
+import { createPat } from './commands/create-pat.js';
+import { createPipeline } from './commands/create-pipeline.js';
+import { deploy } from './commands/deploy.js';
+import { getPipeline } from './commands/get-pipeline.js';
+import { getPlugin } from './commands/get-plugin.js';
+import { instantiateTemplate } from './commands/instantiate-template.js';
+import { listPipelines } from './commands/list-pipelines.js';
+import { listPlugins } from './commands/list-plugins.js';
+import { login } from './commands/login.js';
+import { newPlugin } from './commands/new-plugin.js';
+import { orgExport } from './commands/org-export.js';
+import { provision } from './commands/provision.js';
+import { redriveEvents } from './commands/redrive-events.js';
+import { register } from './commands/register.js';
+import { setupEvents } from './commands/setup-events.js';
+import { status } from './commands/status.js';
+import { storeToken } from './commands/store-token.js';
+import { synth } from './commands/synth.js';
+import { uploadPlugin } from './commands/upload-plugin.js';
+import { validatePlugin } from './commands/validate-plugin.js';
+import { validateTemplatesCommand } from './commands/validate-templates.js';
+import { version } from './commands/version.js';
+import { APP_NAME, APP_DESCRIPTION, APP_VERSION, ENV_VARS, isDebugMode, generateExecutionId, } from './config/cli.constants.js';
+import { banner, miniBanner } from './utils/banner.js';
+import { ERROR_CODES, handleError } from './utils/error-handler.js';
+import { printInfo, printError, printWarning, printDebug, printSection } from './utils/output-utils.js';
+import { preflightCommandTools } from './utils/preflight.js';
+/**
+ * Check environment and display warnings
+ */
+function checkEnvironment() {
+    const warnings = [];
+    // Check for required environment variables
+    if (!process.env[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 < 24) {
+        warnings.push(`Node.js ${nodeVersion} detected - version 24+ required (see package.json engines)`);
+    }
+    // Display warnings
+    if (warnings.length > 0) {
+        printSection('Environment Warnings');
+        warnings.forEach(warning => {
+            printWarning(warning);
+        });
+        console.log('');
+    }
+}
+/**
+ * Display startup information
+ */
+function displayStartupInfo(options) {
+    if (options.quiet)
+        return;
+    const executionId = generateExecutionId();
+    if (options.debug || options.verbose) {
+        printDebug('CLI Configuration', {
+            name: APP_NAME,
+            version: APP_VERSION,
+            executionId,
+            node: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            cwd: process.cwd(),
+            env: {
+                debug: process.env.DEBUG,
+                token: process.env[ENV_VARS.PLATFORM_TOKEN] ? 'set' : 'not set',
+                url: process.env[ENV_VARS.PLATFORM_BASE_URL] || 'default',
+            },
+        });
+    }
+    else {
+        printDebug('Starting CLI', {
+            version: APP_VERSION,
+            executionId,
+        });
+    }
+}
+/**
+ * Register all CLI commands
+ */
+function registerCommands() {
+    printDebug('Registering commands');
+    // Configure program
+    program
+        .name(APP_NAME)
+        .description(APP_DESCRIPTION)
+        .version(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', `
+Command groups:
+  auth      Authenticate and manage credentials (login, pat)
+  pipeline  Create, inspect, and deploy pipelines (create, list, get, register, synth, deploy)
+  plugin    Author, validate, and publish plugins (new, validate, upload, get, list)
+  template  Instantiate golden-path pipeline templates and validate {{ ... }} syntax (instantiate, validate)
+  infra     Set up and operate platform infrastructure (bootstrap, setup-events, redrive-events, store-token, provision)
+  audit     Operator audits, cron-friendly (tokens, stacks)
+  org       Organization data operations (export)
+  status / version / completions
+
+Environment Variables:
+  ${ENV_VARS.PLATFORM_TOKEN} Authentication token (required)
+  ${ENV_VARS.PLATFORM_BASE_URL} API base URL (optional)
+  ${ENV_VARS.CLI_CONFIG_PATH} Config file path (optional)
+  ${ENV_VARS.TLS_REJECT_UNAUTHORIZED} Disable SSL verification if '0'
+  ${ENV_VARS.DEBUG} Enable debug mode if 'true'
+
+Examples:
+  $ ${APP_NAME} version
+  $ ${APP_NAME} auth login -u me@example.com
+  $ ${APP_NAME} pipeline list --project my-app
+  $ ${APP_NAME} pipeline get --id pipe-123 --format json
+  $ ${APP_NAME} pipeline create -f props.json --deploy --profile production
+  $ ${APP_NAME} template instantiate -n react-javascript -p react -o acme --input orgId=<uuid> --output props.json
+  $ ${APP_NAME} plugin upload --file plugin.zip --organization acme
+  $ ${APP_NAME} infra store-token --days 30 --region us-east-1
+  $ ${APP_NAME} infra bootstrap --account 123456789012 --region us-east-1
+  $ ${APP_NAME} pipeline deploy --id pipe-123 --profile production
+
+Exit codes (0 = success; failures use a standard code by error type):
+  1 general · 2 validation · 3 api-request · 4 auth · 5 forbidden
+  6 not-found · 7 network · 8 config · 9 file-system · 10 timeout
+
+Run '${APP_NAME} <group> --help' to see a group's subcommands.
+`);
+    // Fail-fast preflight: before ANY command's action runs, verify the local
+    // tools that command needs. Commander skips this for --help/--version and for
+    // help output, so those always work; API-only commands declare no requirements
+    // and pass through untouched.
+    program.hook('preAction', (_thisCommand, actionCommand) => preflightCommandTools(actionCommand));
+    // Top-level meta commands (no namespace).
+    version(program);
+    status(program); // Show environment and connectivity status
+    // Task namespaces — commands are grouped by the job the user is doing, not by
+    // implementation. Each parent is a subcommand container; the leaf verb lives in
+    // the command file (e.g. `.command('list')`), so `pipeline list` reads as a task.
+    printDebug('Registering task namespaces');
+    // auth — authenticate and manage credentials
+    const auth = program.command('auth').description('Authenticate and manage credentials');
+    login(auth); // auth login — obtain PLATFORM_TOKEN (also supports --refresh)
+    createPat(auth); // auth pat — create a named Personal Access Token
+    // pipeline — create, inspect, and deploy pipelines
+    const pipeline = program.command('pipeline').description('Create, inspect, and deploy pipelines');
+    createPipeline(pipeline); // pipeline create
+    listPipelines(pipeline); // pipeline list
+    getPipeline(pipeline); // pipeline get
+    register(pipeline); // pipeline register — re-register a deployed ARN + drain pending intents
+    synth(pipeline); // pipeline synth — CDK synthesis from pipeline config
+    deploy(pipeline); // pipeline deploy — CDK deploy (--app prints boilerplate path)
+    // plugin — author, validate, and publish plugins
+    const plugin = program.command('plugin').description('Author, validate, and publish plugins');
+    newPlugin(plugin); // plugin new — scaffold a local plugin directory
+    validatePlugin(plugin); // plugin validate — validate a local plugin before upload
+    uploadPlugin(plugin); // plugin upload — upload and deploy
+    getPlugin(plugin); // plugin get
+    listPlugins(plugin); // plugin list
+    // template — instantiate golden-path pipeline templates, validate {{ ... }} syntax
+    const template = program.command('template').description('Instantiate pipeline templates and validate {{ ... }} template syntax');
+    instantiateTemplate(template); // template instantiate — render a template into pipeline props
+    validateTemplatesCommand(template); // template validate
+    // infra — set up and operate platform infrastructure
+    const infra = program.command('infra').description('Set up and operate platform infrastructure');
+    bootstrap(infra); // infra bootstrap — CDK toolkit stack
+    setupEvents(infra); // infra setup-events — EventBridge event ingestion
+    redriveEvents(infra); // infra redrive-events — manual DLQ → queue redrive fallback
+    storeToken(infra); // infra store-token — JWT token in Secrets Manager for CDK
+    provision(infra); // infra provision — AI-assisted deploy/teardown of the platform
+    // audit — operator audits (cron-friendly: exit 1 on findings)
+    const audit = program.command('audit').description('Operator audits (cron-friendly: exit 1 on findings)');
+    auditTokens(audit); // audit tokens — expiring platform tokens in Secrets Manager
+    auditStacks(audit); // audit stacks — CFN stacks vs pipeline_registry drift
+    // org — organization data operations
+    const org = program.command('org').description('Organization data operations');
+    orgExport(org); // org export — GDPR portability export
+    // Shell completions
+    printDebug('Registering completions command');
+    program
+        .command('completions')
+        .description('Generate shell completions (bash, zsh, fish)')
+        .argument('<shell>', 'Shell type: bash, zsh, or fish')
+        .action((shell) => {
+        // Walk commander's registered tree so completions never drift from the actual
+        // surface. `topLevel` is the first-word set (namespaces + meta commands);
+        // `subs` maps each namespace to its leaf verbs for second-word completion.
+        const topLevel = program.commands.map(c => c.name()).sort();
+        const subs = {};
+        for (const c of program.commands) {
+            if (c.commands.length > 0)
+                subs[c.name()] = c.commands.map(s => s.name()).sort();
+        }
+        const topLevelStr = topLevel.join(' ');
+        switch (shell) {
+            case 'bash': {
+                // Two-level: complete the group at word 1, its subcommands at word 2.
+                const cases = Object.entries(subs)
+                    .map(([ns, leaves]) => `      ${ns}) COMPREPLY=($(compgen -W "${leaves.join(' ')}" -- "\${cur}"));;`)
+                    .join('\n');
+                console.log(`# pipeline-manager bash completions
+_pipeline_manager_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "${topLevelStr}" -- "\${cur}"))
+    return
+  fi
+  case "\${COMP_WORDS[1]}" in
+${cases}
+  esac
+}
+complete -F _pipeline_manager_completions pipeline-manager`);
+                break;
+            }
+            case 'zsh': {
+                const cases = Object.entries(subs)
+                    .map(([ns, leaves]) => `        ${ns}) _values 'subcommand' ${leaves.join(' ')};;`)
+                    .join('\n');
+                console.log(`# pipeline-manager zsh completions
+_pipeline_manager() {
+  if (( CURRENT == 2 )); then
+    _values 'command' ${topLevel.join(' ')}
+    return
+  fi
+  case "\${words[2]}" in
+${cases}
+  esac
+}
+compdef _pipeline_manager pipeline-manager`);
+                break;
+            }
+            case 'fish': {
+                const lines = [
+                    `complete -c pipeline-manager -n '__fish_use_subcommand' -a '${topLevelStr}'`,
+                    ...Object.entries(subs).map(([ns, leaves]) => `complete -c pipeline-manager -n '__fish_seen_subcommand_from ${ns}' -a '${leaves.join(' ')}'`),
+                ];
+                console.log(`# pipeline-manager fish completions\n${lines.join('\n')}`);
+                break;
+            }
+            default:
+                console.error(`Unknown shell: ${shell}. Use bash, zsh, or fish.`);
+                process.exit(1);
+        }
+    });
+    printDebug('All commands registered successfully');
+}
+/**
+ * Handle program errors
+ */
+function setupErrorHandlers() {
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        console.error(''); // Empty line
+        printError('Uncaught exception', {
+            error: error.message,
+            name: error.name,
+        });
+        handleError(error, ERROR_CODES.GENERAL, {
+            debug: isDebugMode(program.opts()),
+            exit: true,
+            context: {
+                type: 'uncaughtException',
+            },
+        });
+    });
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason) => {
+        console.error(''); // Empty line
+        printError('Unhandled promise rejection', {
+            reason: reason instanceof Error ? reason.message : String(reason),
+        });
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        handleError(error, ERROR_CODES.GENERAL, {
+            debug: isDebugMode(program.opts()),
+            exit: true,
+            context: {
+                type: 'unhandledRejection',
+            },
+        });
+    });
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+        console.log(''); // Empty line
+        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
+        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
+ */
+export 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) {
+            miniBanner();
+        }
+        else {
+            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();
+        printDebug('CLI initialization complete');
+    }
+    catch (error) {
+        printError('CLI initialization failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        handleError(error, ERROR_CODES.CONFIGURATION, {
+            debug: debug || isDebugMode(),
+            exit: true,
+            context: {
+                stage: 'initialization',
+            },
+        });
+    }
+}
+/**
+ * Parse command line arguments
+ */
+function parseArguments() {
+    try {
+        program.parse(process.argv);
+        // Show help if no command provided
+        const args = process.argv.slice(2);
+        if (args.length === 0) {
+            printInfo('No command specified - displaying help');
+            console.log(''); // Empty line
+            program.outputHelp();
+            process.exit(0);
+        }
+        // Check if command exists
+        const command = args[0];
+        if (command && !command.startsWith('-')) {
+            const commandExists = program.commands.some(cmd => cmd.name() === command);
+            if (!commandExists) {
+                console.log(''); // Empty line
+                printError(`Unknown command: ${command}`);
+                console.log(''); // Empty line
+                printInfo('Available commands:');
+                program.commands.forEach(cmd => {
+                    console.log(` • ${cmd.name()} - ${cmd.description()}`);
+                });
+                console.log(''); // Empty line
+                process.exit(1);
+            }
+        }
+        printDebug('Command line arguments parsed successfully');
+    }
+    catch (error) {
+        handleError(error, ERROR_CODES.GENERAL, {
+            debug: isDebugMode(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 });
+ * ```
+ */
+export function main(options = {}) {
+    try {
+        // Initialize CLI
+        initializeCli(options);
+        // Parse arguments and execute command
+        parseArguments();
+        // If we reach here, command completed successfully
+        printDebug('CLI execution completed successfully');
+    }
+    catch (error) {
+        // Final catch-all error handler
+        console.error(''); // Empty line
+        printError('Fatal CLI error', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        handleError(error, ERROR_CODES.GENERAL, {
+            debug: isDebugMode(options),
+            exit: true,
+            context: {
+                stage: 'main',
+                options,
+            },
+        });
+    }
+}
+/**
+ * Run CLI if executed directly. ESM has no `require.main`; compare the invoked
+ * script to this module's path, resolving symlinks on both sides so the `bin`
+ * symlink (node_modules/.bin/pipeline-manager → dist/cli.js) still matches.
+ */
+const invokedScript = process.argv[1];
+const isMainModule = invokedScript !== undefined
+    && realpathSync(invokedScript) === realpathSync(fileURLToPath(import.meta.url));
+if (isMainModule) {
+    // 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 { realpathSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport { program } from 'commander';\nimport { auditStacks } from './commands/audit-stacks.js';\nimport { auditTokens } from './commands/audit-tokens.js';\nimport { bootstrap } from './commands/bootstrap.js';\nimport { createPat } from './commands/create-pat.js';\nimport { createPipeline } from './commands/create-pipeline.js';\nimport { deploy } from './commands/deploy.js';\nimport { getPipeline } from './commands/get-pipeline.js';\nimport { getPlugin } from './commands/get-plugin.js';\nimport { instantiateTemplate } from './commands/instantiate-template.js';\nimport { listPipelines } from './commands/list-pipelines.js';\nimport { listPlugins } from './commands/list-plugins.js';\nimport { login } from './commands/login.js';\nimport { newPlugin } from './commands/new-plugin.js';\nimport { orgExport } from './commands/org-export.js';\nimport { provision } from './commands/provision.js';\nimport { redriveEvents } from './commands/redrive-events.js';\nimport { register } from './commands/register.js';\nimport { setupEvents } from './commands/setup-events.js';\nimport { status } from './commands/status.js';\nimport { storeToken } from './commands/store-token.js';\nimport { synth } from './commands/synth.js';\nimport { uploadPlugin } from './commands/upload-plugin.js';\nimport { validatePlugin } from './commands/validate-plugin.js';\nimport { validateTemplatesCommand } from './commands/validate-templates.js';\nimport { version } from './commands/version.js';\nimport {\n  APP_NAME,\n  APP_DESCRIPTION,\n  APP_VERSION,\n  ENV_VARS,\n  isDebugMode,\n  generateExecutionId,\n} from './config/cli.constants.js';\nimport { banner, miniBanner } from './utils/banner.js';\nimport { ERROR_CODES, handleError } from './utils/error-handler.js';\nimport { printInfo, printError, printWarning, printDebug, printSection } from './utils/output-utils.js';\nimport { preflightCommandTools } from './utils/preflight.js';\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 < 24) {\n    warnings.push(`Node.js ${nodeVersion} detected - version 24+ required (see package.json engines)`);\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', `\nCommand groups:\n  auth      Authenticate and manage credentials (login, pat)\n  pipeline  Create, inspect, and deploy pipelines (create, list, get, register, synth, deploy)\n  plugin    Author, validate, and publish plugins (new, validate, upload, get, list)\n  template  Instantiate golden-path pipeline templates and validate {{ ... }} syntax (instantiate, validate)\n  infra     Set up and operate platform infrastructure (bootstrap, setup-events, redrive-events, store-token, provision)\n  audit     Operator audits, cron-friendly (tokens, stacks)\n  org       Organization data operations (export)\n  status / version / completions\n\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} auth login -u me@example.com\n  $ ${APP_NAME} pipeline list --project my-app\n  $ ${APP_NAME} pipeline get --id pipe-123 --format json\n  $ ${APP_NAME} pipeline create -f props.json --deploy --profile production\n  $ ${APP_NAME} template instantiate -n react-javascript -p react -o acme --input orgId=<uuid> --output props.json\n  $ ${APP_NAME} plugin upload --file plugin.zip --organization acme\n  $ ${APP_NAME} infra store-token --days 30 --region us-east-1\n  $ ${APP_NAME} infra bootstrap --account 123456789012 --region us-east-1\n  $ ${APP_NAME} pipeline deploy --id pipe-123 --profile production\n\nExit codes (0 = success; failures use a standard code by error type):\n  1 general · 2 validation · 3 api-request · 4 auth · 5 forbidden\n  6 not-found · 7 network · 8 config · 9 file-system · 10 timeout\n\nRun '${APP_NAME} <group> --help' to see a group's subcommands.\n`);\n\n  // Fail-fast preflight: before ANY command's action runs, verify the local\n  // tools that command needs. Commander skips this for --help/--version and for\n  // help output, so those always work; API-only commands declare no requirements\n  // and pass through untouched.\n  program.hook('preAction', (_thisCommand, actionCommand) => preflightCommandTools(actionCommand));\n\n  // Top-level meta commands (no namespace).\n  version(program);\n  status(program); // Show environment and connectivity status\n\n  // Task namespaces — commands are grouped by the job the user is doing, not by\n  // implementation. Each parent is a subcommand container; the leaf verb lives in\n  // the command file (e.g. `.command('list')`), so `pipeline list` reads as a task.\n  printDebug('Registering task namespaces');\n\n  // auth — authenticate and manage credentials\n  const auth = program.command('auth').description('Authenticate and manage credentials');\n  login(auth); // auth login — obtain PLATFORM_TOKEN (also supports --refresh)\n  createPat(auth); // auth pat — create a named Personal Access Token\n\n  // pipeline — create, inspect, and deploy pipelines\n  const pipeline = program.command('pipeline').description('Create, inspect, and deploy pipelines');\n  createPipeline(pipeline); // pipeline create\n  listPipelines(pipeline); // pipeline list\n  getPipeline(pipeline); // pipeline get\n  register(pipeline); // pipeline register — re-register a deployed ARN + drain pending intents\n  synth(pipeline); // pipeline synth — CDK synthesis from pipeline config\n  deploy(pipeline); // pipeline deploy — CDK deploy (--app prints boilerplate path)\n\n  // plugin — author, validate, and publish plugins\n  const plugin = program.command('plugin').description('Author, validate, and publish plugins');\n  newPlugin(plugin); // plugin new — scaffold a local plugin directory\n  validatePlugin(plugin); // plugin validate — validate a local plugin before upload\n  uploadPlugin(plugin); // plugin upload — upload and deploy\n  getPlugin(plugin); // plugin get\n  listPlugins(plugin); // plugin list\n\n  // template — instantiate golden-path pipeline templates, validate {{ ... }} syntax\n  const template = program.command('template').description('Instantiate pipeline templates and validate {{ ... }} template syntax');\n  instantiateTemplate(template); // template instantiate — render a template into pipeline props\n  validateTemplatesCommand(template); // template validate\n\n  // infra — set up and operate platform infrastructure\n  const infra = program.command('infra').description('Set up and operate platform infrastructure');\n  bootstrap(infra); // infra bootstrap — CDK toolkit stack\n  setupEvents(infra); // infra setup-events — EventBridge event ingestion\n  redriveEvents(infra); // infra redrive-events — manual DLQ → queue redrive fallback\n  storeToken(infra); // infra store-token — JWT token in Secrets Manager for CDK\n  provision(infra); // infra provision — AI-assisted deploy/teardown of the platform\n\n  // audit — operator audits (cron-friendly: exit 1 on findings)\n  const audit = program.command('audit').description('Operator audits (cron-friendly: exit 1 on findings)');\n  auditTokens(audit); // audit tokens — expiring platform tokens in Secrets Manager\n  auditStacks(audit); // audit stacks — CFN stacks vs pipeline_registry drift\n\n  // org — organization data operations\n  const org = program.command('org').description('Organization data operations');\n  orgExport(org); // org export — GDPR portability export\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      // Walk commander's registered tree so completions never drift from the actual\n      // surface. `topLevel` is the first-word set (namespaces + meta commands);\n      // `subs` maps each namespace to its leaf verbs for second-word completion.\n      const topLevel = program.commands.map(c => c.name()).sort();\n      const subs: Record<string, string[]> = {};\n      for (const c of program.commands) {\n        if (c.commands.length > 0) subs[c.name()] = c.commands.map(s => s.name()).sort();\n      }\n      const topLevelStr = topLevel.join(' ');\n      switch (shell) {\n        case 'bash': {\n          // Two-level: complete the group at word 1, its subcommands at word 2.\n          const cases = Object.entries(subs)\n            .map(([ns, leaves]) => `      ${ns}) COMPREPLY=($(compgen -W \"${leaves.join(' ')}\" -- \"\\${cur}\"));;`)\n            .join('\\n');\n          console.log(`# pipeline-manager bash completions\n_pipeline_manager_completions() {\n  local cur=\"\\${COMP_WORDS[COMP_CWORD]}\"\n  if [ \"\\${COMP_CWORD}\" -eq 1 ]; then\n    COMPREPLY=($(compgen -W \"${topLevelStr}\" -- \"\\${cur}\"))\n    return\n  fi\n  case \"\\${COMP_WORDS[1]}\" in\n${cases}\n  esac\n}\ncomplete -F _pipeline_manager_completions pipeline-manager`);\n          break;\n        }\n        case 'zsh': {\n          const cases = Object.entries(subs)\n            .map(([ns, leaves]) => `        ${ns}) _values 'subcommand' ${leaves.join(' ')};;`)\n            .join('\\n');\n          console.log(`# pipeline-manager zsh completions\n_pipeline_manager() {\n  if (( CURRENT == 2 )); then\n    _values 'command' ${topLevel.join(' ')}\n    return\n  fi\n  case \"\\${words[2]}\" in\n${cases}\n  esac\n}\ncompdef _pipeline_manager pipeline-manager`);\n          break;\n        }\n        case 'fish': {\n          const lines = [\n            `complete -c pipeline-manager -n '__fish_use_subcommand' -a '${topLevelStr}'`,\n            ...Object.entries(subs).map(([ns, leaves]) =>\n              `complete -c pipeline-manager -n '__fish_seen_subcommand_from ${ns}' -a '${leaves.join(' ')}'`),\n          ];\n          console.log(`# pipeline-manager fish completions\\n${lines.join('\\n')}`);\n          break;\n        }\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. ESM has no `require.main`; compare the invoked\n * script to this module's path, resolving symlinks on both sides so the `bin`\n * symlink (node_modules/.bin/pipeline-manager → dist/cli.js) still matches.\n */\nconst invokedScript = process.argv[1];\nconst isMainModule = invokedScript !== undefined\n  && realpathSync(invokedScript) === realpathSync(fileURLToPath(import.meta.url));\nif (isMainModule) {\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/audit-stacks.d.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+/**
+ * Registers the `audit-stacks` command with the CLI program.
+ *
+ * Diffs CloudFormation stacks (filtered to those tagged with `pipeline-builder`)
+ * against the platform's `pipeline_registry` table. Surfaces:
+ *   - **Orphaned stacks**: tagged stacks with no DB record (likely leftovers after
+ *     a pipeline was deleted from the dashboard but the CDK stack stayed in AWS).
+ *   - **Missing stacks**: registry entries pointing to stacks that no longer exist
+ *     in CloudFormation (likely after a manual `aws cloudformation delete-stack`).
+ *
+ * Designed for cron use:
+ *   - Exits 0 when there are no findings.
+ *   - Exits 1 when at least one orphaned or missing stack is found.
+ *   - Exits 2 on AWS errors / scan failures.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager audit stacks --region us-east-1
+ * pipeline-manager audit stacks --org acme --json
+ * ```
+ */
+export declare function auditStacks(program: Command): void;
+//# sourceMappingURL=audit-stacks.d.ts.map

package/dist/commands/audit-stacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-stacks.d.ts","sourceRoot":"","sources":["../../src/commands/audit-stacks.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoCpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmJlD"}