@pipeline-builder/pipeline-manager 0.0.1

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

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+/**
+ * Registers the `redrive-events` command with the CLI program.
+ *
+ * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls
+ * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`
+ * stack, moving messages that exhausted their receive count in the dead-letter
+ * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes
+ * them. Idempotent ingest (dedupe on `idempotencyKey`) prevents double-counting.
+ *
+ * The Lambda already does this automatically after a successful batch; this
+ * command is the operator escape hatch when the Lambda is down or the DLQ needs
+ * to be drained on demand. Like the Lambda, it refuses to start a second move
+ * task while one is already active (SQS allows only one in-flight task per
+ * source queue anyway).
+ *
+ * @example
+ * ```bash
+ * pipeline-manager infra redrive-events --region us-east-1
+ * pipeline-manager infra redrive-events --region us-east-1 --profile prod
+ * ```
+ */
+export declare function redriveEvents(program: Command): void;
+//# sourceMappingURL=redrive-events.d.ts.map

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

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

package/dist/commands/redrive-events.js

@@ -0,0 +1,127 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
+import { SQSClient, GetQueueAttributesCommand, ListMessageMoveTasksCommand, StartMessageMoveTaskCommand, } from '@aws-sdk/client-sqs';
+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, printWarning } from '../utils/output-utils.js';
+// CFN stack that setup-events deploys — the queues live here.
+const STACK_NAME = EVENTS_STACK_NAME;
+/**
+ * Registers the `redrive-events` command with the CLI program.
+ *
+ * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls
+ * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`
+ * stack, moving messages that exhausted their receive count in the dead-letter
+ * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes
+ * them. Idempotent ingest (dedupe on `idempotencyKey`) prevents double-counting.
+ *
+ * The Lambda already does this automatically after a successful batch; this
+ * command is the operator escape hatch when the Lambda is down or the DLQ needs
+ * to be drained on demand. Like the Lambda, it refuses to start a second move
+ * task while one is already active (SQS allows only one in-flight task per
+ * source queue anyway).
+ *
+ * @example
+ * ```bash
+ * pipeline-manager infra redrive-events --region us-east-1
+ * pipeline-manager infra redrive-events --region us-east-1 --profile prod
+ * ```
+ */
+export function redriveEvents(program) {
+    withProfileOption(withRegionOption(program
+        .command('redrive-events')
+        .description('Redrive dead-lettered CodePipeline events back onto the ingestion queue (manual fallback for the Lambda self-healing redrive)')))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Redrive Events');
+        try {
+            const region = resolveAwsRegion(options.region);
+            // Honor --profile for the SDK clients below (mirrors setup-events) — without
+            // this the SDK hits the DEFAULT account while any accompanying CLI call
+            // honored --profile (silent split-brain).
+            applyAwsProfile(options.profile);
+            printInfo('Parameters', { stack: STACK_NAME, region });
+            // Step 1: resolve the queue URLs from the stack outputs (source of truth —
+            // no hardcoded queue names). setup-events must have run first.
+            printSection('Resolve Queues');
+            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 ?? '']));
+            const eventQueueArn = outputMap.EventQueueArn;
+            const eventQueueUrl = outputMap.EventQueueUrl;
+            const dlqUrl = outputMap.DeadLetterQueueUrl;
+            if (!eventQueueArn || !dlqUrl) {
+                printError(`Stack ${STACK_NAME} is missing expected outputs`, {
+                    hint: 'Run `pipeline-manager infra setup-events` first.',
+                });
+                throw new Error('Stack outputs EventQueueArn / DeadLetterQueueUrl not found');
+            }
+            const sqs = new SQSClient({ region });
+            // The stack exposes the DLQ URL but not its ARN — StartMessageMoveTask needs
+            // the source ARN, so resolve it from the queue's attributes.
+            const dlqAttrs = await sqs.send(new GetQueueAttributesCommand({
+                QueueUrl: dlqUrl,
+                AttributeNames: ['QueueArn', 'ApproximateNumberOfMessages'],
+            }));
+            const dlqArn = dlqAttrs.Attributes?.QueueArn;
+            const dlqDepth = Number(dlqAttrs.Attributes?.ApproximateNumberOfMessages ?? '0');
+            if (!dlqArn) {
+                throw new Error(`Could not resolve the DLQ ARN from ${dlqUrl}`);
+            }
+            printKeyValue({
+                'Source (DLQ)': dlqArn,
+                'Destination (queue)': eventQueueArn,
+                'DLQ depth (approx)': String(dlqDepth),
+            });
+            // Nothing to move — bail early so the operator gets a clear signal instead
+            // of a no-op task.
+            if (dlqDepth === 0) {
+                printSuccess('Dead-letter queue is empty — nothing to redrive.');
+                return;
+            }
+            // Step 2: refuse to stack move tasks. SQS permits only one in-flight move
+            // task per source queue; surface any active one instead of erroring out.
+            printSection('Redrive');
+            const active = await sqs.send(new ListMessageMoveTasksCommand({ SourceArn: dlqArn }));
+            const running = (active.Results ?? []).find(t => t.Status === 'RUNNING');
+            if (running) {
+                printWarning('A message move task is already running for this DLQ — not starting another.', {
+                    taskHandle: running.TaskHandle,
+                    approxMovedSoFar: running.ApproximateNumberOfMessagesMoved,
+                });
+                return;
+            }
+            // Step 3: start the move (DLQ → main queue). DestinationArn is set explicitly
+            // even though SQS would default to the original source queue — the main
+            // ingestion queue is exactly that target.
+            const start = await sqs.send(new StartMessageMoveTaskCommand({
+                SourceArn: dlqArn,
+                DestinationArn: eventQueueArn,
+            }));
+            console.log('');
+            printSection('Redrive Started');
+            printKeyValue({
+                'Task Handle': start.TaskHandle ?? '(none returned)',
+                'Source (DLQ)': dlqArn,
+                'Destination (queue)': eventQueueUrl || eventQueueArn,
+                'Messages queued': String(dlqDepth),
+                'Status': '✓ Started',
+            });
+            console.log('');
+            printSuccess('Redrive task started. Messages will re-flow through the ingestion Lambda.');
+            printInfo('Idempotent ingest dedupes on idempotencyKey, so re-driven events are not double-counted.');
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'redrive-events', executionId, stack: STACK_NAME },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redrive-events.js","sourceRoot":"","sources":["../../src/commands/redrive-events.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';\nimport {\n  SQSClient,\n  GetQueueAttributesCommand,\n  ListMessageMoveTasksCommand,\n  StartMessageMoveTaskCommand,\n} from '@aws-sdk/client-sqs';\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, printWarning } from '../utils/output-utils.js';\n\n// CFN stack that setup-events deploys — the queues live here.\nconst STACK_NAME = EVENTS_STACK_NAME;\n\n/**\n * Registers the `redrive-events` command with the CLI program.\n *\n * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls\n * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`\n * stack, moving messages that exhausted their receive count in the dead-letter\n * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes\n * them. Idempotent ingest (dedupe on `idempotencyKey`) prevents double-counting.\n *\n * The Lambda already does this automatically after a successful batch; this\n * command is the operator escape hatch when the Lambda is down or the DLQ needs\n * to be drained on demand. Like the Lambda, it refuses to start a second move\n * task while one is already active (SQS allows only one in-flight task per\n * source queue anyway).\n *\n * @example\n * ```bash\n * pipeline-manager infra redrive-events --region us-east-1\n * pipeline-manager infra redrive-events --region us-east-1 --profile prod\n * ```\n */\nexport function redriveEvents(program: Command): void {\n  withProfileOption(\n    withRegionOption(program\n      .command('redrive-events')\n      .description('Redrive dead-lettered CodePipeline events back onto the ingestion queue (manual fallback for the Lambda self-healing redrive)')),\n  )\n    .action(async (options) => {\n      const executionId = printCommandHeader('Redrive Events');\n\n      try {\n        const region = resolveAwsRegion(options.region);\n        // Honor --profile for the SDK clients below (mirrors setup-events) — without\n        // this the SDK hits the DEFAULT account while any accompanying CLI call\n        // honored --profile (silent split-brain).\n        applyAwsProfile(options.profile);\n\n        printInfo('Parameters', { stack: STACK_NAME, region });\n\n        // Step 1: resolve the queue URLs from the stack outputs (source of truth —\n        // no hardcoded queue names). setup-events must have run first.\n        printSection('Resolve Queues');\n\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        const eventQueueArn = outputMap.EventQueueArn;\n        const eventQueueUrl = outputMap.EventQueueUrl;\n        const dlqUrl = outputMap.DeadLetterQueueUrl;\n\n        if (!eventQueueArn || !dlqUrl) {\n          printError(`Stack ${STACK_NAME} is missing expected outputs`, {\n            hint: 'Run `pipeline-manager infra setup-events` first.',\n          });\n          throw new Error('Stack outputs EventQueueArn / DeadLetterQueueUrl not found');\n        }\n\n        const sqs = new SQSClient({ region });\n\n        // The stack exposes the DLQ URL but not its ARN — StartMessageMoveTask needs\n        // the source ARN, so resolve it from the queue's attributes.\n        const dlqAttrs = await sqs.send(new GetQueueAttributesCommand({\n          QueueUrl: dlqUrl,\n          AttributeNames: ['QueueArn', 'ApproximateNumberOfMessages'],\n        }));\n        const dlqArn = dlqAttrs.Attributes?.QueueArn;\n        const dlqDepth = Number(dlqAttrs.Attributes?.ApproximateNumberOfMessages ?? '0');\n\n        if (!dlqArn) {\n          throw new Error(`Could not resolve the DLQ ARN from ${dlqUrl}`);\n        }\n\n        printKeyValue({\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueArn,\n          'DLQ depth (approx)': String(dlqDepth),\n        });\n\n        // Nothing to move — bail early so the operator gets a clear signal instead\n        // of a no-op task.\n        if (dlqDepth === 0) {\n          printSuccess('Dead-letter queue is empty — nothing to redrive.');\n          return;\n        }\n\n        // Step 2: refuse to stack move tasks. SQS permits only one in-flight move\n        // task per source queue; surface any active one instead of erroring out.\n        printSection('Redrive');\n\n        const active = await sqs.send(new ListMessageMoveTasksCommand({ SourceArn: dlqArn }));\n        const running = (active.Results ?? []).find(t => t.Status === 'RUNNING');\n        if (running) {\n          printWarning('A message move task is already running for this DLQ — not starting another.', {\n            taskHandle: running.TaskHandle,\n            approxMovedSoFar: running.ApproximateNumberOfMessagesMoved,\n          });\n          return;\n        }\n\n        // Step 3: start the move (DLQ → main queue). DestinationArn is set explicitly\n        // even though SQS would default to the original source queue — the main\n        // ingestion queue is exactly that target.\n        const start = await sqs.send(new StartMessageMoveTaskCommand({\n          SourceArn: dlqArn,\n          DestinationArn: eventQueueArn,\n        }));\n\n        console.log('');\n        printSection('Redrive Started');\n        printKeyValue({\n          'Task Handle': start.TaskHandle ?? '(none returned)',\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueUrl || eventQueueArn,\n          'Messages queued': String(dlqDepth),\n          'Status': '✓ Started',\n        });\n\n        console.log('');\n        printSuccess('Redrive task started. Messages will re-flow through the ingestion Lambda.');\n        printInfo('Idempotent ingest dedupes on idempotencyKey, so re-driven events are not double-counted.');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'redrive-events', executionId, stack: STACK_NAME },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/register.d.ts

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+/**
+ * Registers the `register` command with the CLI program.
+ *
+ * Two purposes — both targeted at recovering from a deploy whose registration
+ * step didn't land:
+ *
+ *   1. Explicit re-register (`--id <pipelineId>`) — recomputes the ARN from
+ *      STS + region and POSTs it to the platform. Useful when the platform
+ *      was unreachable during `deploy`, when the registry row was deleted by
+ *      mistake, or for any other reason a deployed stack has no registry row.
+ *
+ *   2. Drain pending intents (every invocation) — `deploy` writes a local
+ *      file under `~/.pipeline-manager/pending-registrations/` whenever its
+ *      registration POST fails. Each `register` invocation tries to drain
+ *      every such file. On success the file is deleted; on failure it stays
+ *      and surfaces as a warning.
+ *
+ * Flags:
+ *   - `--id <pipelineId>` — re-register a specific pipeline by ID
+ *   - `--region <region>` — AWS region (default: AWS_REGION env / us-east-1)
+ *   - `--no-drain` — skip draining pending intents
+ *
+ * Exit codes:
+ *   - 0: requested registration succeeded AND no pending intents remain
+ *   - 1: at least one registration (explicit or pending) still failed
+ *
+ * @example
+ * ```bash
+ * # Retry a registration that failed during deploy
+ * pipeline-manager pipeline register --id pipe-123
+ *
+ * # Just drain pending intents from disk, no specific registration
+ * pipeline-manager pipeline register
+ * ```
+ */
+export declare function register(program: Command): void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/commands/register.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwG/C"}

package/dist/commands/register.js

@@ -0,0 +1,160 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import {} from '../types/index.js';
+import { createAuthenticatedClient, printCommandHeader, printSslWarning, withRegionOption, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { buildRegistryPayload, clearPendingIntent, readPendingIntents, writePendingIntent, } from '../utils/registry.js';
+import { extractSingleResponse } from '../utils/response-utils.js';
+/**
+ * Registers the `register` command with the CLI program.
+ *
+ * Two purposes — both targeted at recovering from a deploy whose registration
+ * step didn't land:
+ *
+ *   1. Explicit re-register (`--id <pipelineId>`) — recomputes the ARN from
+ *      STS + region and POSTs it to the platform. Useful when the platform
+ *      was unreachable during `deploy`, when the registry row was deleted by
+ *      mistake, or for any other reason a deployed stack has no registry row.
+ *
+ *   2. Drain pending intents (every invocation) — `deploy` writes a local
+ *      file under `~/.pipeline-manager/pending-registrations/` whenever its
+ *      registration POST fails. Each `register` invocation tries to drain
+ *      every such file. On success the file is deleted; on failure it stays
+ *      and surfaces as a warning.
+ *
+ * Flags:
+ *   - `--id <pipelineId>` — re-register a specific pipeline by ID
+ *   - `--region <region>` — AWS region (default: AWS_REGION env / us-east-1)
+ *   - `--no-drain` — skip draining pending intents
+ *
+ * Exit codes:
+ *   - 0: requested registration succeeded AND no pending intents remain
+ *   - 1: at least one registration (explicit or pending) still failed
+ *
+ * @example
+ * ```bash
+ * # Retry a registration that failed during deploy
+ * pipeline-manager pipeline register --id pipe-123
+ *
+ * # Just drain pending intents from disk, no specific registration
+ * pipeline-manager pipeline register
+ * ```
+ */
+export function register(program) {
+    withSslOptions(withRegionOption(program
+        .command('register')
+        .description('Register a deployed pipeline ARN with the platform (retry path for failed registrations)')
+        .option('-i, --id <id>', 'Pipeline ID to register (re-derives ARN from STS)'))
+        .option('--no-drain', 'Skip draining pending intents from prior failed deploys'))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Register Pipeline');
+        printSslWarning(options.verifySsl);
+        let anyFailed = false;
+        let registeredCount = 0;
+        try {
+            const client = createAuthenticatedClient(options);
+            const pipelineUrl = client.getConfig().api.pipelineUrl;
+            // ── Drain pending intents first ──
+            // We drain before the explicit registration so a queued failure for
+            // the same pipelineId is replaced (not double-applied) by the fresh
+            // payload below.
+            const drained = new Set();
+            if (options.drain !== false) {
+                const intents = await readPendingIntents();
+                if (intents.length > 0) {
+                    printSection('Draining pending intents');
+                    printInfo('Found pending registrations from prior failed deploys', {
+                        count: String(intents.length),
+                    });
+                    for (const intent of intents) {
+                        // Skip the explicit pipeline — we'll re-build a fresh payload below.
+                        if (options.id && intent.pipelineId === options.id)
+                            continue;
+                        const ok = await postRegistration(client, pipelineUrl, intent, intent.pipelineId);
+                        if (ok) {
+                            await clearPendingIntent(intent.pipelineId);
+                            drained.add(intent.pipelineId);
+                            registeredCount++;
+                        }
+                        else {
+                            anyFailed = true;
+                        }
+                    }
+                }
+            }
+            // ── Explicit registration ──
+            if (options.id) {
+                printSection('Re-registering pipeline');
+                const pipelineRes = await client.get(`${pipelineUrl}/${options.id}`);
+                const pipeline = extractSingleResponse(pipelineRes, 'pipeline', 'id');
+                if (!pipeline) {
+                    printError('Pipeline not found in platform');
+                    throw new Error(`No pipeline returned for id ${options.id}`);
+                }
+                if (!pipeline.orgId) {
+                    printError('Pipeline has no orgId — cannot register');
+                    throw new Error(`Pipeline ${pipeline.id} is missing orgId`);
+                }
+                const payload = await buildRegistryPayload({
+                    id: pipeline.id,
+                    orgId: pipeline.orgId,
+                    pipelineName: pipeline.pipelineName,
+                    project: pipeline.project,
+                    organization: pipeline.organization,
+                }, options.region);
+                // Clear any stale intent for this pipelineId before retrying so we
+                // don't leave a duplicate file behind on success.
+                await clearPendingIntent(payload.pipelineId);
+                const ok = await postRegistration(client, pipelineUrl, payload, payload.pipelineId);
+                if (ok) {
+                    registeredCount++;
+                    printSuccess('Pipeline registered for event reporting', {
+                        pipelineId: payload.pipelineId,
+                    });
+                }
+                else {
+                    anyFailed = true;
+                    const path = await writePendingIntent(payload);
+                    printWarning('Registration failed; intent saved for retry', { intent: path });
+                }
+            }
+            printSection('Summary');
+            printKeyValue({
+                'Registered': String(registeredCount),
+                'Drained from queue': String(drained.size),
+                'Status': anyFailed ? 'Some registrations still pending' : 'All clear',
+                'Execution ID': executionId,
+            });
+            process.exit(anyFailed ? 1 : 0);
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: false,
+                context: { command: 'register', executionId, pipelineId: options.id },
+            });
+            process.exit(1);
+        }
+    });
+}
+/**
+ * POST a registration payload to the platform. On failure, the caller decides
+ * whether to write/preserve a pending intent — this helper just reports.
+ */
+async function postRegistration(client, pipelineUrl, payload, pipelineId) {
+    try {
+        await client.post(`${pipelineUrl}/registry`, payload);
+        printInfo('Registered', { pipelineId });
+        return true;
+    }
+    catch (err) {
+        printWarning('Registration failed', {
+            pipelineId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"register.js","sourceRoot":"","sources":["../../src/commands/register.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAwC,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC7I,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC1H,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GAEnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAgB;IACvC,cAAc,CAAC,gBAAgB,CAAC,OAAO;SACpC,OAAO,CAAC,UAAU,CAAC;SACnB,WAAW,CAAC,0FAA0F,CAAC;SACvG,MAAM,CAAC,eAAe,EAAE,mDAAmD,CAAC,CAAC;SAC7E,MAAM,CAAC,YAAY,EAAE,yDAAyD,CAAC,CAAC;SAChF,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACxB,MAAM,WAAW,GAAG,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;QAC5D,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEnC,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,IAAI,eAAe,GAAG,CAAC,CAAC;QAExB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;YAClD,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC;YAEvD,oCAAoC;YACpC,oEAAoE;YACpE,oEAAoE;YACpE,iBAAiB;YACjB,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;YAClC,IAAI,OAAO,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;gBAC5B,MAAM,OAAO,GAAG,MAAM,kBAAkB,EAAE,CAAC;gBAC3C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACvB,YAAY,CAAC,0BAA0B,CAAC,CAAC;oBACzC,SAAS,CAAC,uDAAuD,EAAE;wBACjE,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;qBAC9B,CAAC,CAAC;oBACH,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;wBAC7B,qEAAqE;wBACrE,IAAI,OAAO,CAAC,EAAE,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC,EAAE;4BAAE,SAAS;wBAC7D,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;wBAClF,IAAI,EAAE,EAAE,CAAC;4BACP,MAAM,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;4BAC5C,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;4BAC/B,eAAe,EAAE,CAAC;wBACpB,CAAC;6BAAM,CAAC;4BACN,SAAS,GAAG,IAAI,CAAC;wBACnB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;YAED,8BAA8B;YAC9B,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;gBACf,YAAY,CAAC,yBAAyB,CAAC,CAAC;gBACxC,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,GAAG,CAAmB,GAAG,WAAW,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvF,MAAM,QAAQ,GAAG,qBAAqB,CAAW,WAAW,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;gBAChF,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,UAAU,CAAC,gCAAgC,CAAC,CAAC;oBAC7C,MAAM,IAAI,KAAK,CAAC,+BAA+B,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC/D,CAAC;gBAED,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;oBACpB,UAAU,CAAC,yCAAyC,CAAC,CAAC;oBACtD,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,CAAC,EAAE,mBAAmB,CAAC,CAAC;gBAC9D,CAAC;gBACD,MAAM,OAAO,GAAG,MAAM,oBAAoB,CACxC;oBACE,EAAE,EAAE,QAAQ,CAAC,EAAE;oBACf,KAAK,EAAE,QAAQ,CAAC,KAAK;oBACrB,YAAY,EAAE,QAAQ,CAAC,YAAY;oBACnC,OAAO,EAAE,QAAQ,CAAC,OAAO;oBACzB,YAAY,EAAE,QAAQ,CAAC,YAAY;iBACpC,EACD,OAAO,CAAC,MAAM,CACf,CAAC;gBAEF,mEAAmE;gBACnE,kDAAkD;gBAClD,MAAM,kBAAkB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;gBAE7C,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;gBACpF,IAAI,EAAE,EAAE,CAAC;oBACP,eAAe,EAAE,CAAC;oBAClB,YAAY,CAAC,yCAAyC,EAAE;wBACtD,UAAU,EAAE,OAAO,CAAC,UAAU;qBAC/B,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,SAAS,GAAG,IAAI,CAAC;oBACjB,MAAM,IAAI,GAAG,MAAM,kBAAkB,CAAC,OAAO,CAAC,CAAC;oBAC/C,YAAY,CAAC,6CAA6C,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;gBAChF,CAAC;YACH,CAAC;YAED,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,aAAa,CAAC;gBACZ,YAAY,EAAE,MAAM,CAAC,eAAe,CAAC;gBACrC,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBAC1C,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC,WAAW;gBACtE,cAAc,EAAE,WAAW;aAC5B,CAAC,CAAC;YAEH,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,EAAE;gBAC1C,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK;gBAC3B,IAAI,EAAE,KAAK;gBACX,OAAO,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE;aACtE,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,gBAAgB,CAC7B,MAAoD,EACpD,WAAmB,EACnB,OAAwB,EACxB,UAAkB;IAElB,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,IAAI,CAAC,GAAG,WAAW,WAAW,EAAE,OAAO,CAAC,CAAC;QACtD,SAAS,CAAC,YAAY,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,YAAY,CAAC,qBAAqB,EAAE;YAClC,UAAU;YACV,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;SACxD,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport { type Pipeline, type PipelineResponse } from '../types/index.js';\nimport { createAuthenticatedClient, printCommandHeader, printSslWarning, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport {\n  buildRegistryPayload,\n  clearPendingIntent,\n  readPendingIntents,\n  writePendingIntent,\n  type RegistryPayload,\n} from '../utils/registry.js';\nimport { extractSingleResponse } from '../utils/response-utils.js';\n\n/**\n * Registers the `register` command with the CLI program.\n *\n * Two purposes — both targeted at recovering from a deploy whose registration\n * step didn't land:\n *\n *   1. Explicit re-register (`--id <pipelineId>`) — recomputes the ARN from\n *      STS + region and POSTs it to the platform. Useful when the platform\n *      was unreachable during `deploy`, when the registry row was deleted by\n *      mistake, or for any other reason a deployed stack has no registry row.\n *\n *   2. Drain pending intents (every invocation) — `deploy` writes a local\n *      file under `~/.pipeline-manager/pending-registrations/` whenever its\n *      registration POST fails. Each `register` invocation tries to drain\n *      every such file. On success the file is deleted; on failure it stays\n *      and surfaces as a warning.\n *\n * Flags:\n *   - `--id <pipelineId>` — re-register a specific pipeline by ID\n *   - `--region <region>` — AWS region (default: AWS_REGION env / us-east-1)\n *   - `--no-drain` — skip draining pending intents\n *\n * Exit codes:\n *   - 0: requested registration succeeded AND no pending intents remain\n *   - 1: at least one registration (explicit or pending) still failed\n *\n * @example\n * ```bash\n * # Retry a registration that failed during deploy\n * pipeline-manager pipeline register --id pipe-123\n *\n * # Just drain pending intents from disk, no specific registration\n * pipeline-manager pipeline register\n * ```\n */\nexport function register(program: Command): void {\n  withSslOptions(withRegionOption(program\n    .command('register')\n    .description('Register a deployed pipeline ARN with the platform (retry path for failed registrations)')\n    .option('-i, --id <id>', 'Pipeline ID to register (re-derives ARN from STS)'))\n    .option('--no-drain', 'Skip draining pending intents from prior failed deploys'))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Register Pipeline');\n      printSslWarning(options.verifySsl);\n\n      let anyFailed = false;\n      let registeredCount = 0;\n\n      try {\n        const client = createAuthenticatedClient(options);\n        const pipelineUrl = client.getConfig().api.pipelineUrl;\n\n        // ── Drain pending intents first ──\n        // We drain before the explicit registration so a queued failure for\n        // the same pipelineId is replaced (not double-applied) by the fresh\n        // payload below.\n        const drained = new Set<string>();\n        if (options.drain !== false) {\n          const intents = await readPendingIntents();\n          if (intents.length > 0) {\n            printSection('Draining pending intents');\n            printInfo('Found pending registrations from prior failed deploys', {\n              count: String(intents.length),\n            });\n            for (const intent of intents) {\n              // Skip the explicit pipeline — we'll re-build a fresh payload below.\n              if (options.id && intent.pipelineId === options.id) continue;\n              const ok = await postRegistration(client, pipelineUrl, intent, intent.pipelineId);\n              if (ok) {\n                await clearPendingIntent(intent.pipelineId);\n                drained.add(intent.pipelineId);\n                registeredCount++;\n              } else {\n                anyFailed = true;\n              }\n            }\n          }\n        }\n\n        // ── Explicit registration ──\n        if (options.id) {\n          printSection('Re-registering pipeline');\n          const pipelineRes = await client.get<PipelineResponse>(`${pipelineUrl}/${options.id}`);\n          const pipeline = extractSingleResponse<Pipeline>(pipelineRes, 'pipeline', 'id');\n          if (!pipeline) {\n            printError('Pipeline not found in platform');\n            throw new Error(`No pipeline returned for id ${options.id}`);\n          }\n\n          if (!pipeline.orgId) {\n            printError('Pipeline has no orgId — cannot register');\n            throw new Error(`Pipeline ${pipeline.id} is missing orgId`);\n          }\n          const payload = await buildRegistryPayload(\n            {\n              id: pipeline.id,\n              orgId: pipeline.orgId,\n              pipelineName: pipeline.pipelineName,\n              project: pipeline.project,\n              organization: pipeline.organization,\n            },\n            options.region,\n          );\n\n          // Clear any stale intent for this pipelineId before retrying so we\n          // don't leave a duplicate file behind on success.\n          await clearPendingIntent(payload.pipelineId);\n\n          const ok = await postRegistration(client, pipelineUrl, payload, payload.pipelineId);\n          if (ok) {\n            registeredCount++;\n            printSuccess('Pipeline registered for event reporting', {\n              pipelineId: payload.pipelineId,\n            });\n          } else {\n            anyFailed = true;\n            const path = await writePendingIntent(payload);\n            printWarning('Registration failed; intent saved for retry', { intent: path });\n          }\n        }\n\n        printSection('Summary');\n        printKeyValue({\n          'Registered': String(registeredCount),\n          'Drained from queue': String(drained.size),\n          'Status': anyFailed ? 'Some registrations still pending' : 'All clear',\n          'Execution ID': executionId,\n        });\n\n        process.exit(anyFailed ? 1 : 0);\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: false,\n          context: { command: 'register', executionId, pipelineId: options.id },\n        });\n        process.exit(1);\n      }\n    });\n}\n\n/**\n * POST a registration payload to the platform. On failure, the caller decides\n * whether to write/preserve a pending intent — this helper just reports.\n */\nasync function postRegistration(\n  client: ReturnType<typeof createAuthenticatedClient>,\n  pipelineUrl: string,\n  payload: RegistryPayload,\n  pipelineId: string,\n): Promise<boolean> {\n  try {\n    await client.post(`${pipelineUrl}/registry`, payload);\n    printInfo('Registered', { pipelineId });\n    return true;\n  } catch (err) {\n    printWarning('Registration failed', {\n      pipelineId,\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n}\n"]}

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

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+/**
+ * Registers the `setup-events` command with the CLI program.
+ *
+ * Deploys EventBridge → SQS → Lambda infrastructure for pipeline reporting.
+ *
+ * 1. Deploys CloudFormation stack (rule + queue + Lambda shell + IAM)
+ * 2. Downloads @pipeline-builder/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 declare function setupEvents(program: Command): void;
+//# sourceMappingURL=setup-events.d.ts.map

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

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