@pipeline-builder/pipeline-manager 0.0.1

package/dist/utils/deploy-runner.js

@@ -0,0 +1,112 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pico from 'picocolors';
+import { executeCdkShellCommand, resolveBoilerplatePath } from './cdk-utils.js';
+import { ensureOutputDirectory, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';
+import { buildRegistryPayload, writePendingIntent } from './registry.js';
+import { assertShellSafe, shellQuote } from '../config/cli.constants.js';
+import {} from '../types/index.js';
+const { bold, cyan, dim } = pico;
+// ESM has no __dirname; derive it from this module's URL. `resolveBoilerplatePath`
+// returns `../boilerplate.js`, which is the same target whether resolved from
+// src/commands or src/utils (both are siblings under src/), so this stays correct.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Run `cdk deploy` for an already-resolved pipeline, then register the deployed
+ * ARN for event reporting (best-effort). Shared by `pipeline deploy` and
+ * `pipeline create --deploy` so the two entry points never drift.
+ *
+ * THROWS on CDK failure (the caller maps it to a non-zero exit and, for the
+ * create path, keeps the created record and prints the `deploy --id` retry).
+ * Registry failures are NON-fatal — they're queued to a pending-intent file for
+ * `pipeline register` to drain later.
+ */
+export async function runDeploy(input) {
+    const { pipeline, propsWithIds, profile, region, requireApproval, output, debug, executionId } = input;
+    const encoded = Buffer.from(JSON.stringify(propsWithIds), 'utf-8').toString('base64');
+    printInfo('Preparing output directory', { path: output });
+    ensureOutputDirectory(output);
+    // Validate EVERY input that flows into the shell (interpolated unquoted below).
+    if (profile)
+        assertShellSafe(profile, 'profile');
+    assertShellSafe(output, 'output');
+    assertShellSafe(requireApproval, 'require-approval');
+    // `assertShellSafe` rejects shell metacharacters but ALLOWS spaces, so quote
+    // every interpolated value (a path/profile with a space would otherwise split
+    // into extra cdk args — matching how the agent path quotes them).
+    const scriptPath = resolveBoilerplatePath(__dirname);
+    const profileArg = profile ? `--profile=${shellQuote(profile)}` : '';
+    const outputArg = `--output=${shellQuote(output)}`;
+    const appArg = `--app="node ${scriptPath}"`;
+    const command = `cdk deploy ${profileArg} --require-approval=${shellQuote(requireApproval)} ${outputArg} --notices=false ${appArg}`;
+    printSection('CDK Execution');
+    console.log(cyan(bold('Command:')), dim(command.split(' --')[0] + ' ...'));
+    console.log('');
+    // Forward the resolved platform base URL into the CDK synth subprocess (it reads
+    // only process.env) for the PluginLookup Lambda endpoint + registry pull-host
+    // fallback. Absent in local-spec mode.
+    const cdkEnv = { PIPELINE_PROPS: encoded };
+    if (input.platformBaseUrl)
+        cdkEnv.PLATFORM_BASE_URL = input.platformBaseUrl;
+    // Throws on failure — surfaced by the caller as a non-zero exit.
+    const result = executeCdkShellCommand(command, { debug, showOutput: true, env: cdkEnv });
+    console.log('');
+    printSection('Deployment Complete');
+    printKeyValue({
+        'Execution ID': executionId,
+        'Duration': `${result.duration}ms`,
+        'Output Directory': output,
+        'Status': '✓ Success',
+    });
+    // Register the pipeline ARN for event reporting (non-blocking). Skipped when
+    // there's no platform client (local-spec) or no orgId to scope it to.
+    if (!input.platformClient || !input.platformPipelineUrl) {
+        printInfo('Skipping pipeline registry (no platform client)');
+        return;
+    }
+    if (!pipeline.orgId) {
+        printWarning('Pipeline has no orgId — skipping registration');
+        return;
+    }
+    // Build the payload up-front so a POST failure can persist the SAME payload as a
+    // pending intent for `pipeline register` to drain later (STS lookups aren't retried).
+    let payload;
+    try {
+        payload = await buildRegistryPayload({
+            id: pipeline.id,
+            orgId: pipeline.orgId,
+            pipelineName: pipeline.pipelineName,
+            project: pipeline.project,
+            organization: pipeline.organization,
+        }, region);
+    }
+    catch (buildError) {
+        printWarning('Could not build registry payload — skipping registration', {
+            error: buildError instanceof Error ? buildError.message : String(buildError),
+        });
+        return;
+    }
+    try {
+        await input.platformClient.post(`${input.platformPipelineUrl}/registry`, payload);
+        printSuccess('Pipeline registered for event reporting', { pipelineId: payload.pipelineId });
+    }
+    catch (regError) {
+        try {
+            const intentPath = await writePendingIntent(payload);
+            printWarning('Pipeline registry update failed; queued for retry', {
+                error: regError instanceof Error ? regError.message : String(regError),
+                retry: 'pipeline-manager pipeline register',
+                intent: intentPath,
+            });
+        }
+        catch (writeErr) {
+            printWarning('Pipeline registry update failed (retry queue also failed)', {
+                error: regError instanceof Error ? regError.message : String(regError),
+                queueError: writeErr instanceof Error ? writeErr.message : String(writeErr),
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-runner.js","sourceRoot":"","sources":["../../src/utils/deploy-runner.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport pico from 'picocolors';\nimport { executeCdkShellCommand, resolveBoilerplatePath } from './cdk-utils.js';\nimport { ensureOutputDirectory, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { buildRegistryPayload, writePendingIntent } from './registry.js';\nimport { assertShellSafe, shellQuote } from '../config/cli.constants.js';\nimport { type Pipeline } from '../types/index.js';\n\nconst { bold, cyan, dim } = pico;\n\n// ESM has no __dirname; derive it from this module's URL. `resolveBoilerplatePath`\n// returns `../boilerplate.js`, which is the same target whether resolved from\n// src/commands or src/utils (both are siblings under src/), so this stays correct.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\n/** Minimal platform client shape needed to register a deployed ARN. */\ninterface RegistryClient {\n  post: (url: string, body: unknown) => Promise<unknown>;\n}\n\n/** Inputs for {@link runDeploy} — an already-resolved pipeline + props. */\nexport interface RunDeployInput {\n  /** The pipeline being deployed (id/orgId/name/project/org drive registration). */\n  pipeline: Pick<Pipeline, 'id' | 'orgId' | 'pipelineName' | 'project' | 'organization'>;\n  /** Fully-resolved props (plugins pre-resolved, registry host baked, ids included). */\n  propsWithIds: Record<string, unknown>;\n  /** AWS profile / region for the deploy + registry payload. */\n  profile?: string;\n  region?: string;\n  /** `cdk deploy --require-approval` level and `--output` dir. */\n  requireApproval: string;\n  output: string;\n  debug?: boolean;\n  /** For the command header / summary line. */\n  executionId: string;\n  /** Registry callback — omit (e.g. --local-spec) to skip ARN registration. */\n  platformClient?: RegistryClient;\n  platformPipelineUrl?: string;\n  platformBaseUrl?: string;\n}\n\n/**\n * Run `cdk deploy` for an already-resolved pipeline, then register the deployed\n * ARN for event reporting (best-effort). Shared by `pipeline deploy` and\n * `pipeline create --deploy` so the two entry points never drift.\n *\n * THROWS on CDK failure (the caller maps it to a non-zero exit and, for the\n * create path, keeps the created record and prints the `deploy --id` retry).\n * Registry failures are NON-fatal — they're queued to a pending-intent file for\n * `pipeline register` to drain later.\n */\nexport async function runDeploy(input: RunDeployInput): Promise<void> {\n  const { pipeline, propsWithIds, profile, region, requireApproval, output, debug, executionId } = input;\n\n  const encoded = Buffer.from(JSON.stringify(propsWithIds), 'utf-8').toString('base64');\n\n  printInfo('Preparing output directory', { path: output });\n  ensureOutputDirectory(output);\n\n  // Validate EVERY input that flows into the shell (interpolated unquoted below).\n  if (profile) assertShellSafe(profile, 'profile');\n  assertShellSafe(output, 'output');\n  assertShellSafe(requireApproval, 'require-approval');\n\n  // `assertShellSafe` rejects shell metacharacters but ALLOWS spaces, so quote\n  // every interpolated value (a path/profile with a space would otherwise split\n  // into extra cdk args — matching how the agent path quotes them).\n  const scriptPath = resolveBoilerplatePath(__dirname);\n  const profileArg = profile ? `--profile=${shellQuote(profile)}` : '';\n  const outputArg = `--output=${shellQuote(output)}`;\n  const appArg = `--app=\"node ${scriptPath}\"`;\n  const command = `cdk deploy ${profileArg} --require-approval=${shellQuote(requireApproval)} ${outputArg} --notices=false ${appArg}`;\n\n  printSection('CDK Execution');\n  console.log(cyan(bold('Command:')), dim(command.split(' --')[0] + ' ...'));\n  console.log('');\n\n  // Forward the resolved platform base URL into the CDK synth subprocess (it reads\n  // only process.env) for the PluginLookup Lambda endpoint + registry pull-host\n  // fallback. Absent in local-spec mode.\n  const cdkEnv: Record<string, string> = { PIPELINE_PROPS: encoded };\n  if (input.platformBaseUrl) cdkEnv.PLATFORM_BASE_URL = input.platformBaseUrl;\n\n  // Throws on failure — surfaced by the caller as a non-zero exit.\n  const result = executeCdkShellCommand(command, { debug, showOutput: true, env: cdkEnv });\n\n  console.log('');\n  printSection('Deployment Complete');\n  printKeyValue({\n    'Execution ID': executionId,\n    'Duration': `${result.duration}ms`,\n    'Output Directory': output,\n    'Status': '✓ Success',\n  });\n\n  // Register the pipeline ARN for event reporting (non-blocking). Skipped when\n  // there's no platform client (local-spec) or no orgId to scope it to.\n  if (!input.platformClient || !input.platformPipelineUrl) {\n    printInfo('Skipping pipeline registry (no platform client)');\n    return;\n  }\n  if (!pipeline.orgId) {\n    printWarning('Pipeline has no orgId — skipping registration');\n    return;\n  }\n\n  // Build the payload up-front so a POST failure can persist the SAME payload as a\n  // pending intent for `pipeline register` to drain later (STS lookups aren't retried).\n  let payload;\n  try {\n    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      region,\n    );\n  } catch (buildError) {\n    printWarning('Could not build registry payload — skipping registration', {\n      error: buildError instanceof Error ? buildError.message : String(buildError),\n    });\n    return;\n  }\n\n  try {\n    await input.platformClient.post(`${input.platformPipelineUrl}/registry`, payload);\n    printSuccess('Pipeline registered for event reporting', { pipelineId: payload.pipelineId });\n  } catch (regError) {\n    try {\n      const intentPath = await writePendingIntent(payload);\n      printWarning('Pipeline registry update failed; queued for retry', {\n        error: regError instanceof Error ? regError.message : String(regError),\n        retry: 'pipeline-manager pipeline register',\n        intent: intentPath,\n      });\n    } catch (writeErr) {\n      printWarning('Pipeline registry update failed (retry queue also failed)', {\n        error: regError instanceof Error ? regError.message : String(regError),\n        queueError: writeErr instanceof Error ? writeErr.message : String(writeErr),\n      });\n    }\n  }\n}\n"]}

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,29 @@
+import { ERROR_CODES, type ErrorCode, type ErrorHandlerOptions } from '../types/index.js';
+export { ERROR_CODES };
+export type { ErrorCode };
+/**
+ * Format and handle errors with colored output
+ */
+export declare function handleError(err: unknown, code?: ErrorCode, options?: ErrorHandlerOptions): never;
+/**
+ * Validation error class
+ */
+export declare class ValidationError extends Error {
+    field?: string | undefined;
+    value?: unknown;
+    rule?: string | undefined;
+    expected?: string | undefined;
+    constructor(message: string, field?: string | undefined, value?: unknown, rule?: string | undefined, expected?: string | undefined);
+}
+/**
+ * Network error class
+ */
+export declare class NetworkError extends Error {
+    url?: string | undefined;
+    cause?: Error | undefined;
+    timeout?: number | undefined;
+    requestMade: boolean;
+    responseReceived: boolean;
+    constructor(message: string, url?: string | undefined, cause?: Error | undefined, timeout?: number | undefined, requestMade?: boolean, responseReceived?: boolean);
+}
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EACX,KAAK,SAAS,EACd,KAAK,mBAAmB,EAEzB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;GAEG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE,SAA+B,EACrC,OAAO,GAAE,mBAAwB,GAChC,KAAK,CAiHP;AAID;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IAG/B,KAAK,CAAC,EAAE,MAAM;IACd,KAAK,CAAC,EAAE,OAAO;IACf,IAAI,CAAC,EAAE,MAAM;IACb,QAAQ,CAAC,EAAE,MAAM;IAL1B,YACE,OAAO,EAAE,MAAM,EACR,KAAK,CAAC,EAAE,MAAM,YAAA,EACd,KAAK,CAAC,EAAE,OAAO,EACf,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,QAAQ,CAAC,EAAE,MAAM,YAAA,EAKzB;CACF;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAG5B,GAAG,CAAC,EAAE,MAAM;IACZ,KAAK,CAAC,EAAE,KAAK;IACb,OAAO,CAAC,EAAE,MAAM;IAChB,WAAW,EAAE,OAAO;IACpB,gBAAgB,EAAE,OAAO;IANlC,YACE,OAAO,EAAE,MAAM,EACR,GAAG,CAAC,EAAE,MAAM,YAAA,EACZ,KAAK,CAAC,EAAE,KAAK,YAAA,EACb,OAAO,CAAC,EAAE,MAAM,YAAA,EAChB,WAAW,GAAE,OAAc,EAC3B,gBAAgB,GAAE,OAAe,EAKzC;CACF"}

package/dist/utils/error-handler.js

@@ -0,0 +1,302 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import pico from 'picocolors';
+import { generateExecutionId } from '../config/cli.constants.js';
+import { ERROR_CODES, } from '../types/index.js';
+const { bold, dim, red, yellow, cyan } = pico;
+// Re-export for convenience
+export { ERROR_CODES };
+/**
+ * Format and handle errors with colored output
+ */
+export function handleError(err, code = ERROR_CODES.GENERAL, options = {}) {
+    const { debug = false, exit = true, logToConsole = true, context, correlationId = generateExecutionId(), } = options;
+    // Derive the canonical exit code from the ACTUAL error (see resolveExitCode),
+    // falling back to the caller's `code` for anything unclassifiable. This is what
+    // makes every command emit the SAME exit code for the same class of failure,
+    // rather than a blanket API_REQUEST/GENERAL. Used for display, the suggestion,
+    // and the process exit below.
+    const resolvedCode = resolveExitCode(err, code);
+    if (logToConsole) {
+        const divider = '─'.repeat(process.stdout.columns || 80);
+        const errorId = `ERR-${correlationId}`;
+        console.error('\n' + red(bold('✗ ERROR')) + dim(` [${errorId}]`) + '\n');
+        console.error(dim(divider));
+        if (err instanceof Error) {
+            console.error(red(bold('Message:')), err.message);
+            if (err.name !== 'Error') {
+                console.error(red('Type:'), err.name);
+            }
+            // Show Validation error details
+            if (err instanceof ValidationError) {
+                if (err.field)
+                    console.error(red('Field:'), err.field);
+                if (err.value !== undefined)
+                    console.error(red('Value:'), sanitizeValue(err.value));
+                if (err.rule)
+                    console.error(red('Rule:'), err.rule);
+                if (err.expected)
+                    console.error(red('Expected:'), err.expected);
+            }
+            // Show Network error details
+            if (err instanceof NetworkError) {
+                if (err.url)
+                    console.error(red('URL:'), sanitizeUrl(err.url));
+                if (err.timeout)
+                    console.error(red('Timeout:'), `${err.timeout}ms`);
+                console.error(red('Request Made:'), err.requestMade ? 'Yes' : 'No');
+                console.error(red('Response Received:'), err.responseReceived ? 'Yes' : 'No');
+                if (err.cause)
+                    console.error(red('Caused by:'), err.cause.message);
+            }
+            // Show Axios error details
+            if (isAxiosError(err)) {
+                const status = err.response?.status;
+                const url = err.config?.url;
+                if (status) {
+                    console.error(red('Status:'), status);
+                    console.error(red('Status Text:'), getHttpStatusText(status));
+                }
+                if (url)
+                    console.error(red('URL:'), sanitizeUrl(url));
+                if (err.response?.data) {
+                    console.error(red('Response:'));
+                    console.error(dim(sanitizeErrorData(err.response.data)));
+                }
+            }
+            // Show CDK/execSync error details (stderr captured from child process)
+            if ('stderr' in err && err.stderr) {
+                const stderr = err.stderr.toString().trim();
+                if (stderr) {
+                    console.error(red('CDK Output:'));
+                    console.error(dim(stderr));
+                }
+            }
+            console.error(red('Code:'), getErrorCodeName(resolvedCode));
+            console.error(dim('Error ID:'), dim(errorId));
+            if (context && Object.keys(context).length > 0) {
+                console.error('');
+                console.error(red('Context:'));
+                Object.entries(context).forEach(([key, value]) => {
+                    console.error(`  ${cyan(key)}:`, dim(sanitizeValue(value)));
+                });
+            }
+            if (debug && err.stack) {
+                console.error('');
+                console.error(dim('Stack trace:'));
+                console.error(dim(sanitizeStackTrace(err.stack)));
+            }
+        }
+        else {
+            console.error(red('Error:'), String(err));
+            console.error(red('Code:'), getErrorCodeName(resolvedCode));
+            console.error(dim('Error ID:'), dim(errorId));
+        }
+        console.error(dim(divider));
+        if (!debug) {
+            console.error(yellow('💡 Tip:'), dim('Run with --debug flag to see full stack trace'));
+        }
+        const suggestion = getErrorSuggestion(err, resolvedCode);
+        if (suggestion) {
+            console.error(yellow('💡 Suggestion:'), dim(suggestion));
+        }
+        console.error('');
+    }
+    if (exit) {
+        process.exitCode = resolvedCode;
+        process.exit(resolvedCode);
+    }
+    throw err;
+}
+// --- Error classes (only those actually used) ---
+/**
+ * Validation error class
+ */
+export class ValidationError extends Error {
+    field;
+    value;
+    rule;
+    expected;
+    constructor(message, field, value, rule, expected) {
+        super(message);
+        this.field = field;
+        this.value = value;
+        this.rule = rule;
+        this.expected = expected;
+        this.name = 'ValidationError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Network error class
+ */
+export class NetworkError extends Error {
+    url;
+    cause;
+    timeout;
+    requestMade;
+    responseReceived;
+    constructor(message, url, cause, timeout, requestMade = true, responseReceived = false) {
+        super(message);
+        this.url = url;
+        this.cause = cause;
+        this.timeout = timeout;
+        this.requestMade = requestMade;
+        this.responseReceived = responseReceived;
+        this.name = 'NetworkError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+// --- Private helpers ---
+/**
+ * Map the ACTUAL error to a canonical exit code so every command exits with the
+ * SAME code for the same class of failure. The caller-supplied `fallback` (e.g.
+ * API_REQUEST) is used only for errors this can't classify. Codes (src/types/error.ts):
+ *
+ *   1 GENERAL · 2 VALIDATION · 3 API_REQUEST · 4 AUTHENTICATION · 5 AUTHORIZATION
+ *   6 NOT_FOUND · 7 NETWORK · 8 CONFIGURATION · 9 FILE_SYSTEM · 10 TIMEOUT
+ *
+ * Precedence: typed CLI errors → HTTP status → Node system error `code` → fallback.
+ */
+function resolveExitCode(err, fallback) {
+    if (err instanceof ValidationError)
+        return ERROR_CODES.VALIDATION;
+    if (err instanceof NetworkError)
+        return err.timeout ? ERROR_CODES.TIMEOUT : ERROR_CODES.NETWORK;
+    if (isAxiosError(err)) {
+        const status = err.response?.status;
+        if (status === 400 || status === 422)
+            return ERROR_CODES.VALIDATION;
+        if (status === 401)
+            return ERROR_CODES.AUTHENTICATION;
+        if (status === 403)
+            return ERROR_CODES.AUTHORIZATION;
+        if (status === 404)
+            return ERROR_CODES.NOT_FOUND;
+        if (status === 408 || status === 504)
+            return ERROR_CODES.TIMEOUT;
+        if (status && status >= 500)
+            return ERROR_CODES.API_REQUEST;
+        // A request that got no HTTP response never reached the server (DNS / refused
+        // / reset) — that's a network failure, not an API-response error.
+        if (!err.response)
+            return ERROR_CODES.NETWORK;
+        return fallback;
+    }
+    // Node system errors (fs + sockets) carry a string `code`.
+    const sysCode = err?.code;
+    if (typeof sysCode === 'string') {
+        if (['ENOENT', 'EACCES', 'EISDIR', 'ENOTDIR', 'EEXIST', 'EPERM', 'ENOSPC', 'EMFILE'].includes(sysCode)) {
+            return ERROR_CODES.FILE_SYSTEM;
+        }
+        if (sysCode === 'ETIMEDOUT')
+            return ERROR_CODES.TIMEOUT;
+        if (['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN', 'EPIPE'].includes(sysCode)) {
+            return ERROR_CODES.NETWORK;
+        }
+    }
+    return fallback;
+}
+function getErrorCodeName(code) {
+    const entry = Object.entries(ERROR_CODES).find(([_, value]) => value === code);
+    return entry ? `${entry[0]} (${code})` : String(code);
+}
+function getHttpStatusText(status) {
+    const statusTexts = {
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        408: 'Request Timeout',
+        409: 'Conflict',
+        422: 'Unprocessable Entity',
+        429: 'Too Many Requests',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        504: 'Gateway Timeout',
+    };
+    return statusTexts[status] || 'Unknown';
+}
+function getErrorSuggestion(err, code) {
+    if (code === ERROR_CODES.AUTHENTICATION) {
+        return 'Check that PLATFORM_TOKEN environment variable is set correctly';
+    }
+    if (code === ERROR_CODES.NETWORK) {
+        return 'Check your internet connection and API endpoint URL';
+    }
+    if (code === ERROR_CODES.CONFIGURATION) {
+        return 'Run "cli version --check-config" to verify configuration';
+    }
+    if (code === ERROR_CODES.NOT_FOUND) {
+        return 'Verify the resource ID exists and you have access to it';
+    }
+    if (err instanceof Error && err.message.includes('cdk')) {
+        return 'Check the CDK output above for CloudFormation errors. Run with --debug for full details';
+    }
+    if (err instanceof ValidationError && err.field) {
+        return `Check the value provided for "${err.field}"`;
+    }
+    if (isAxiosError(err)) {
+        const status = err.response?.status;
+        if (status === 401 || status === 403)
+            return 'Check your authentication token and permissions';
+        if (status === 429)
+            return 'Rate limit exceeded - wait a moment before retrying';
+        if (status && status >= 500)
+            return 'Server error - try again later or contact support';
+    }
+    return null;
+}
+function sanitizeErrorData(data) {
+    if (typeof data === 'string')
+        return data;
+    if (typeof data === 'object' && data !== null) {
+        const sanitized = { ...data };
+        ['token', 'password', 'secret', 'apiKey', 'authorization', 'jwt', 'credential', 'bearer'].forEach(field => {
+            if (field in sanitized)
+                sanitized[field] = '[REDACTED]';
+        });
+        return JSON.stringify(sanitized, null, 2);
+    }
+    return String(data);
+}
+function sanitizeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        ['token', 'key', 'secret', 'password', 'apiKey'].forEach(param => {
+            if (urlObj.searchParams.has(param))
+                urlObj.searchParams.set(param, '[REDACTED]');
+        });
+        return urlObj.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function sanitizeValue(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'string') {
+        if (value.length > 20 && /^[A-Za-z0-9+/=_-]+$/.test(value)) {
+            return `${value.substring(0, 8)}...[REDACTED]`;
+        }
+        return value.length > 100 ? value.substring(0, 97) + '...' : value;
+    }
+    if (typeof value === 'object')
+        return sanitizeErrorData(value);
+    const str = String(value);
+    return str.length > 100 ? str.substring(0, 97) + '...' : str;
+}
+function sanitizeStackTrace(stack) {
+    return stack.split('\n').slice(0, 10).map(line => line.replace(/\/.*?\//g, '.../')).join('\n');
+}
+function isAxiosError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'isAxiosError' in err &&
+        err.isAxiosError === true);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.js","sourceRoot":"","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport pico from 'picocolors';\nimport { generateExecutionId } from '../config/cli.constants.js';\nimport {\n  ERROR_CODES,\n  type ErrorCode,\n  type ErrorHandlerOptions,\n  type AxiosErrorLike,\n} from '../types/index.js';\n\nconst { bold, dim, red, yellow, cyan } = pico;\n\n// Re-export for convenience\nexport { ERROR_CODES };\nexport type { ErrorCode };\n\n/**\n * Format and handle errors with colored output\n */\nexport function handleError(\n  err: unknown,\n  code: ErrorCode = ERROR_CODES.GENERAL,\n  options: ErrorHandlerOptions = {},\n): never {\n  const {\n    debug = false,\n    exit = true,\n    logToConsole = true,\n    context,\n    correlationId = generateExecutionId(),\n  } = options;\n\n  // Derive the canonical exit code from the ACTUAL error (see resolveExitCode),\n  // falling back to the caller's `code` for anything unclassifiable. This is what\n  // makes every command emit the SAME exit code for the same class of failure,\n  // rather than a blanket API_REQUEST/GENERAL. Used for display, the suggestion,\n  // and the process exit below.\n  const resolvedCode = resolveExitCode(err, code);\n\n  if (logToConsole) {\n    const divider = '─'.repeat(process.stdout.columns || 80);\n    const errorId = `ERR-${correlationId}`;\n\n    console.error('\\n' + red(bold('✗ ERROR')) + dim(` [${errorId}]`) + '\\n');\n    console.error(dim(divider));\n\n    if (err instanceof Error) {\n      console.error(red(bold('Message:')), err.message);\n\n      if (err.name !== 'Error') {\n        console.error(red('Type:'), err.name);\n      }\n\n      // Show Validation error details\n      if (err instanceof ValidationError) {\n        if (err.field) console.error(red('Field:'), err.field);\n        if (err.value !== undefined) console.error(red('Value:'), sanitizeValue(err.value));\n        if (err.rule) console.error(red('Rule:'), err.rule);\n        if (err.expected) console.error(red('Expected:'), err.expected);\n      }\n\n      // Show Network error details\n      if (err instanceof NetworkError) {\n        if (err.url) console.error(red('URL:'), sanitizeUrl(err.url));\n        if (err.timeout) console.error(red('Timeout:'), `${err.timeout}ms`);\n        console.error(red('Request Made:'), err.requestMade ? 'Yes' : 'No');\n        console.error(red('Response Received:'), err.responseReceived ? 'Yes' : 'No');\n        if (err.cause) console.error(red('Caused by:'), err.cause.message);\n      }\n\n      // Show Axios error details\n      if (isAxiosError(err)) {\n        const status = err.response?.status;\n        const url = err.config?.url;\n        if (status) {\n          console.error(red('Status:'), status);\n          console.error(red('Status Text:'), getHttpStatusText(status));\n        }\n        if (url) console.error(red('URL:'), sanitizeUrl(url));\n        if (err.response?.data) {\n          console.error(red('Response:'));\n          console.error(dim(sanitizeErrorData(err.response.data)));\n        }\n      }\n\n      // Show CDK/execSync error details (stderr captured from child process)\n      if ('stderr' in err && err.stderr) {\n        const stderr = (err.stderr as Buffer | string).toString().trim();\n        if (stderr) {\n          console.error(red('CDK Output:'));\n          console.error(dim(stderr));\n        }\n      }\n\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n\n      if (context && Object.keys(context).length > 0) {\n        console.error('');\n        console.error(red('Context:'));\n        Object.entries(context).forEach(([key, value]) => {\n          console.error(`  ${cyan(key)}:`, dim(sanitizeValue(value)));\n        });\n      }\n\n      if (debug && err.stack) {\n        console.error('');\n        console.error(dim('Stack trace:'));\n        console.error(dim(sanitizeStackTrace(err.stack)));\n      }\n    } else {\n      console.error(red('Error:'), String(err));\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n    }\n\n    console.error(dim(divider));\n\n    if (!debug) {\n      console.error(yellow('💡 Tip:'), dim('Run with --debug flag to see full stack trace'));\n    }\n\n    const suggestion = getErrorSuggestion(err, resolvedCode);\n    if (suggestion) {\n      console.error(yellow('💡 Suggestion:'), dim(suggestion));\n    }\n\n    console.error('');\n  }\n\n  if (exit) {\n    process.exitCode = resolvedCode;\n    process.exit(resolvedCode);\n  }\n\n  throw err;\n}\n\n// --- Error classes (only those actually used) ---\n\n/**\n * Validation error class\n */\nexport class ValidationError extends Error {\n  constructor(\n    message: string,\n    public field?: string,\n    public value?: unknown,\n    public rule?: string,\n    public expected?: string,\n  ) {\n    super(message);\n    this.name = 'ValidationError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n/**\n * Network error class\n */\nexport class NetworkError extends Error {\n  constructor(\n    message: string,\n    public url?: string,\n    public cause?: Error,\n    public timeout?: number,\n    public requestMade: boolean = true,\n    public responseReceived: boolean = false,\n  ) {\n    super(message);\n    this.name = 'NetworkError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n// --- Private helpers ---\n\n/**\n * Map the ACTUAL error to a canonical exit code so every command exits with the\n * SAME code for the same class of failure. The caller-supplied `fallback` (e.g.\n * API_REQUEST) is used only for errors this can't classify. Codes (src/types/error.ts):\n *\n *   1 GENERAL · 2 VALIDATION · 3 API_REQUEST · 4 AUTHENTICATION · 5 AUTHORIZATION\n *   6 NOT_FOUND · 7 NETWORK · 8 CONFIGURATION · 9 FILE_SYSTEM · 10 TIMEOUT\n *\n * Precedence: typed CLI errors → HTTP status → Node system error `code` → fallback.\n */\nfunction resolveExitCode(err: unknown, fallback: ErrorCode): ErrorCode {\n  if (err instanceof ValidationError) return ERROR_CODES.VALIDATION;\n  if (err instanceof NetworkError) return err.timeout ? ERROR_CODES.TIMEOUT : ERROR_CODES.NETWORK;\n\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 400 || status === 422) return ERROR_CODES.VALIDATION;\n    if (status === 401) return ERROR_CODES.AUTHENTICATION;\n    if (status === 403) return ERROR_CODES.AUTHORIZATION;\n    if (status === 404) return ERROR_CODES.NOT_FOUND;\n    if (status === 408 || status === 504) return ERROR_CODES.TIMEOUT;\n    if (status && status >= 500) return ERROR_CODES.API_REQUEST;\n    // A request that got no HTTP response never reached the server (DNS / refused\n    // / reset) — that's a network failure, not an API-response error.\n    if (!err.response) return ERROR_CODES.NETWORK;\n    return fallback;\n  }\n\n  // Node system errors (fs + sockets) carry a string `code`.\n  const sysCode = (err as { code?: unknown } | null)?.code;\n  if (typeof sysCode === 'string') {\n    if (['ENOENT', 'EACCES', 'EISDIR', 'ENOTDIR', 'EEXIST', 'EPERM', 'ENOSPC', 'EMFILE'].includes(sysCode)) {\n      return ERROR_CODES.FILE_SYSTEM;\n    }\n    if (sysCode === 'ETIMEDOUT') return ERROR_CODES.TIMEOUT;\n    if (['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN', 'EPIPE'].includes(sysCode)) {\n      return ERROR_CODES.NETWORK;\n    }\n  }\n\n  return fallback;\n}\n\nfunction getErrorCodeName(code: ErrorCode): string {\n  const entry = Object.entries(ERROR_CODES).find(([_, value]) => value === code);\n  return entry ? `${entry[0]} (${code})` : String(code);\n}\n\nfunction getHttpStatusText(status: number): string {\n  const statusTexts: Record<number, string> = {\n    400: 'Bad Request',\n    401: 'Unauthorized',\n    403: 'Forbidden',\n    404: 'Not Found',\n    408: 'Request Timeout',\n    409: 'Conflict',\n    422: 'Unprocessable Entity',\n    429: 'Too Many Requests',\n    500: 'Internal Server Error',\n    502: 'Bad Gateway',\n    503: 'Service Unavailable',\n    504: 'Gateway Timeout',\n  };\n  return statusTexts[status] || 'Unknown';\n}\n\nfunction getErrorSuggestion(err: unknown, code: ErrorCode): string | null {\n  if (code === ERROR_CODES.AUTHENTICATION) {\n    return 'Check that PLATFORM_TOKEN environment variable is set correctly';\n  }\n  if (code === ERROR_CODES.NETWORK) {\n    return 'Check your internet connection and API endpoint URL';\n  }\n  if (code === ERROR_CODES.CONFIGURATION) {\n    return 'Run \"cli version --check-config\" to verify configuration';\n  }\n  if (code === ERROR_CODES.NOT_FOUND) {\n    return 'Verify the resource ID exists and you have access to it';\n  }\n  if (err instanceof Error && err.message.includes('cdk')) {\n    return 'Check the CDK output above for CloudFormation errors. Run with --debug for full details';\n  }\n  if (err instanceof ValidationError && err.field) {\n    return `Check the value provided for \"${err.field}\"`;\n  }\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 401 || status === 403) return 'Check your authentication token and permissions';\n    if (status === 429) return 'Rate limit exceeded - wait a moment before retrying';\n    if (status && status >= 500) return 'Server error - try again later or contact support';\n  }\n  return null;\n}\n\nfunction sanitizeErrorData(data: unknown): string {\n  if (typeof data === 'string') return data;\n  if (typeof data === 'object' && data !== null) {\n    const sanitized = { ...data } as Record<string, unknown>;\n    ['token', 'password', 'secret', 'apiKey', 'authorization', 'jwt', 'credential', 'bearer'].forEach(field => {\n      if (field in sanitized) sanitized[field] = '[REDACTED]';\n    });\n    return JSON.stringify(sanitized, null, 2);\n  }\n  return String(data);\n}\n\nfunction sanitizeUrl(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    ['token', 'key', 'secret', 'password', 'apiKey'].forEach(param => {\n      if (urlObj.searchParams.has(param)) urlObj.searchParams.set(param, '[REDACTED]');\n    });\n    return urlObj.toString();\n  } catch {\n    return url;\n  }\n}\n\nfunction sanitizeValue(value: unknown): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  if (typeof value === 'string') {\n    if (value.length > 20 && /^[A-Za-z0-9+/=_-]+$/.test(value)) {\n      return `${value.substring(0, 8)}...[REDACTED]`;\n    }\n    return value.length > 100 ? value.substring(0, 97) + '...' : value;\n  }\n  if (typeof value === 'object') return sanitizeErrorData(value);\n  const str = String(value);\n  return str.length > 100 ? str.substring(0, 97) + '...' : str;\n}\n\nfunction sanitizeStackTrace(stack: string): string {\n  return stack.split('\\n').slice(0, 10).map(line => line.replace(/\\/.*?\\//g, '.../')).join('\\n');\n}\n\nfunction isAxiosError(err: unknown): err is AxiosErrorLike {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'isAxiosError' in err &&\n    (err as Record<string, unknown>).isAxiosError === true\n  );\n}\n"]}

package/dist/utils/list-command-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Common filter parameters shared by all list commands.
+ */
+export interface CommonFilterParams {
+    id?: string | string[];
+    isActive?: boolean;
+    limit?: number;
+    offset?: number;
+    sort?: string;
+}
+/**
+ * Extract common filter parameters (id, isActive, limit, offset, sort) from CLI options.
+ */
+export declare function buildCommonFilters(options: Record<string, unknown>): CommonFilterParams;
+/**
+ * Display pagination settings for a list command.
+ */
+export declare function displayPaginationInfo(filterParams: CommonFilterParams): void;
+/**
+ * Display result summary after a list query completes.
+ */
+export declare function displayListResults(items: unknown[], total: number | undefined, hasMore: boolean, entityName: string, duration: number, filterParams: CommonFilterParams): void;
+//# sourceMappingURL=list-command-utils.d.ts.map

package/dist/utils/list-command-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-command-utils.d.ts","sourceRoot":"","sources":["../../src/utils/list-command-utils.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,kBAAkB,CAmBvF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAQ5E;AAGD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EAAE,EAChB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,kBAAkB,GAC/B,IAAI,CAgBN"}

package/dist/utils/list-command-utils.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { printInfo, printKeyValue } from './output-utils.js';
+import { formatDuration, validateBoolean, validateNumber, validateSort } from '../config/cli.constants.js';
+/** Default page size when a list command's caller omits --limit. */
+const DEFAULT_LIST_LIMIT = 50;
+/**
+ * Extract common filter parameters (id, isActive, limit, offset, sort) from CLI options.
+ */
+export function buildCommonFilters(options) {
+    const params = {};
+    if (options.id) {
+        const idValue = options.id;
+        params.id = idValue.includes(',') ? idValue.split(',').map((s) => s.trim()) : idValue;
+    }
+    if (options.isActive !== undefined) {
+        params.isActive = validateBoolean(options.isActive, 'is-active');
+    }
+    params.limit = validateNumber(options.limit, 'limit', 1, 1000);
+    params.offset = validateNumber(options.offset, 'offset', 0);
+    const sort = validateSort(options.sort);
+    if (sort)
+        params.sort = sort;
+    return params;
+}
+/**
+ * Display pagination settings for a list command.
+ */
+export function displayPaginationInfo(filterParams) {
+    console.log('');
+    printInfo('Pagination Settings');
+    printKeyValue({
+        Limit: (filterParams.limit ?? DEFAULT_LIST_LIMIT).toString(),
+        Offset: (filterParams.offset ?? 0).toString(),
+        Sort: filterParams.sort || 'createdAt:desc',
+    });
+}
+/**
+ * Display result summary after a list query completes.
+ */
+export function displayListResults(items, total, hasMore, entityName, duration, filterParams) {
+    printKeyValue({
+        [`${entityName} Found`]: items.length.toString(),
+        'Total Available': total !== undefined ? total.toString() : 'Unknown',
+        'Has More': hasMore ? 'Yes' : 'No',
+        'Request Duration': formatDuration(duration),
+    });
+    if (hasMore) {
+        const currentOffset = filterParams.offset || 0;
+        const nextOffset = currentOffset + (filterParams.limit || DEFAULT_LIST_LIMIT);
+        console.log('');
+        printInfo('More results available', {
+            hint: `Use --offset ${nextOffset} to see next page`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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