@fjall/deploy-core 0.89.2

package/dist/src/aws/utils/cloudformationEvents.js

@@ -0,0 +1,596 @@
+import { CloudFormationClient, DescribeStackEventsCommand, DescribeStacksCommand } from "@aws-sdk/client-cloudformation";
+import { logger } from "@fjall/util";
+import { getErrorMessage } from "@fjall/util";
+import { maskSensitiveOutput } from "../../util/securityHelpers.js";
+import { sleep } from "../../util/sleep.js";
+// CloudFormation error pattern for stacks that haven't been created yet
+export const STACK_NOT_FOUND_PATTERN = "does not exist";
+// CDK error string indicating the targeted stack does not exist in the synthesised output
+export const CDK_NO_STACKS_MATCH = "No stacks match the name(s)";
+export function isResourceEvent(event) {
+    return (typeof event === "object" &&
+        event !== null &&
+        "logicalId" in event &&
+        "resourceType" in event &&
+        "status" in event);
+}
+export class CloudFormationEventMonitor {
+    aws;
+    seenEventIds = new Set();
+    isMonitoring = false;
+    pollInterval = null;
+    activeNestedStacks = new Map(); // Track nested stack states across polls
+    failureReasons = new Map(); // Track failure reasons for resources
+    eventHistory = new Map(); // Complete event history per resource
+    eventLogger = null;
+    failureAnalyser;
+    eventLogWriterFactory;
+    lastAnalysis = null;
+    deploymentStartTime = null;
+    // 1 000 events ≈ a large CDK stack; caps memory during multi-hour deploys
+    maxHistorySize = 1000;
+    // 10 000 IDs ≈ 10 large stacks; prevents unbounded Set growth across retries
+    maxSeenEventIds = 10000;
+    // Track in-progress IPAM resources for concurrency diagnostics
+    ipamInProgress = new Map();
+    constructor(aws, deps) {
+        this.aws = aws;
+        this.failureAnalyser = deps?.failureAnalyser ?? null;
+        this.eventLogWriterFactory = deps?.eventLogWriterFactory;
+    }
+    enableLogging(deploymentId, stackName, region, deploymentName) {
+        if (this.eventLogWriterFactory) {
+            this.eventLogger = this.eventLogWriterFactory(deploymentId, stackName, region, deploymentName);
+        }
+    }
+    async startMonitoring(stackName, onResourceUpdate, onStackComplete) {
+        if (this.isMonitoring) {
+            logger.debug("CloudFormation", "startMonitoring SKIPPED - already monitoring", { stackName });
+            return;
+        }
+        logger.debug("CloudFormation", "startMonitoring STARTED", { stackName });
+        this.isMonitoring = true;
+        this.seenEventIds.clear();
+        this.eventHistory.clear();
+        this.deploymentStartTime = new Date();
+        try {
+            await this.pollEvents(stackName, () => { });
+        }
+        catch (error) {
+            // Stack might not exist yet — only log unexpected errors
+            const msg = getErrorMessage(error);
+            if (!msg.includes(STACK_NOT_FOUND_PATTERN)) {
+                logger.debug("CloudFormation", "Initial poll failed", { error: msg });
+            }
+        }
+        // AWS CDK uses 5 second intervals, but we'll use a more conservative approach
+        // to avoid rate limiting, especially for accounts with many concurrent operations
+        let pollDelay = 5000; // Start at 5 seconds (matching CDK default)
+        const maxPollDelay = 10000; // Max 10 seconds between polls
+        let pollCount = 0;
+        let throttleCount = 0;
+        const poll = async () => {
+            if (!this.isMonitoring) {
+                return;
+            }
+            try {
+                const result = await this.pollEvents(stackName, onResourceUpdate);
+                pollCount++;
+                // If we're being throttled, implement exponential backoff
+                if (result === "throttled") {
+                    throttleCount++;
+                    // Exponential backoff: 5s, 10s, 20s, 40s (capped at 30s)
+                    pollDelay = Math.min(30000, 5000 * Math.pow(2, throttleCount - 1));
+                }
+                else {
+                    // Reset throttle count on successful poll
+                    throttleCount = 0;
+                    // After initial polls, gradually increase interval to reduce API calls
+                    // This helps with long-running operations (10+ minutes)
+                    if (pollCount > 20 && pollDelay < maxPollDelay) {
+                        pollDelay = Math.min(maxPollDelay, pollDelay + 1000);
+                    }
+                    else if (pollCount <= 20) {
+                        // Keep at 5s for first ~100 seconds to maintain good visibility
+                        pollDelay = 5000;
+                    }
+                }
+                if (result === true) {
+                    this.stopMonitoring();
+                    // Get final stack status
+                    const finalStatusObj = await this.getStackStatus(stackName);
+                    const finalStatus = finalStatusObj?.status || "UNKNOWN";
+                    const success = finalStatus.endsWith("_COMPLETE") &&
+                        !finalStatus.includes("ROLLBACK") &&
+                        !finalStatus.includes("FAILED");
+                    // Get first failure reason if deployment failed
+                    let failureMessage = finalStatusObj?.statusReason || undefined;
+                    if (!success && this.failureReasons.size > 0) {
+                        const firstFailure = Array.from(this.failureReasons.values())[0];
+                        failureMessage = firstFailure || failureMessage;
+                    }
+                    // Log deployment completion
+                    if (this.eventLogger) {
+                        this.eventLogger.writeDeploymentEnd(success || false, finalStatus, failureMessage);
+                        // If failed, log all failure reasons collected
+                        if (!success && this.failureReasons.size > 0) {
+                            this.eventLogger.writeFailureSummary(Array.from(this.failureReasons.entries()).map(([logicalId, reason]) => ({
+                                logicalId,
+                                reason
+                            })));
+                        }
+                        // Also log failure analysis if available
+                        if (!success && this.failureAnalyser) {
+                            const analysis = this.failureAnalyser.analyseFailure(this.eventHistory);
+                            this.lastAnalysis = analysis;
+                            if (analysis) {
+                                this.eventLogger.writeFailureAnalysis({
+                                    rootCause: analysis.rootCause.reason,
+                                    failedResources: analysis.affectedResources.map((r) => ({
+                                        logicalId: r.logicalId,
+                                        resourceType: r.resourceType,
+                                        reason: r.statusReason || "Unknown reason"
+                                    })),
+                                    dependencyChain: analysis.dependencyChain,
+                                    remediation: analysis.remediation
+                                });
+                            }
+                        }
+                    }
+                    if (onStackComplete) {
+                        onStackComplete(success || false, failureMessage);
+                    }
+                }
+                else {
+                    // Schedule next poll
+                    this.pollInterval = setTimeout(poll, pollDelay);
+                }
+            }
+            catch (error) {
+                logger.debug("CloudFormation", "Polling iteration error (continuing)", {
+                    error: getErrorMessage(error)
+                });
+                this.pollInterval = setTimeout(poll, pollDelay);
+            }
+        };
+        // Start polling
+        this.pollInterval = setTimeout(poll, pollDelay);
+    }
+    stopMonitoring() {
+        logger.debug("CloudFormation", "stopMonitoring called", {
+            wasMonitoring: this.isMonitoring,
+            seenEventCount: this.seenEventIds.size
+        });
+        this.isMonitoring = false;
+        if (this.pollInterval) {
+            clearTimeout(this.pollInterval);
+            this.pollInterval = null;
+        }
+        this.cleanup();
+    }
+    cleanup() {
+        this.activeNestedStacks.clear();
+        this.failureReasons.clear();
+        this.eventHistory.clear();
+        this.ipamInProgress.clear();
+        if (this.seenEventIds.size > this.maxSeenEventIds) {
+            const idsArray = Array.from(this.seenEventIds);
+            const keepCount = Math.floor(this.maxSeenEventIds / 2);
+            this.seenEventIds = new Set(idsArray.slice(-keepCount));
+        }
+        if (this.eventLogger) {
+            this.eventLogger = null;
+        }
+    }
+    getResourceHistory(logicalId) {
+        return this.eventHistory.get(logicalId) || [];
+    }
+    getEventHistory() {
+        return new Map(this.eventHistory);
+    }
+    getFailureAnalysis() {
+        return this.lastAnalysis;
+    }
+    getFirstFailureReason() {
+        if (this.failureReasons.size > 0) {
+            return Array.from(this.failureReasons.values())[0];
+        }
+        return null;
+    }
+    getEventLogger() {
+        return this.eventLogger;
+    }
+    getEventLogPath() {
+        return this.eventLogger?.getLogPath() || null;
+    }
+    getLogSummary() {
+        return this.eventLogger?.getLogSummary() || null;
+    }
+    async waitForStackComplete(stackName, options = {}) {
+        const { timeout = 30 * 60 * 1000, // 30 minutes default
+        pollInterval = 2000, // 2 seconds
+        onResourceUpdate, onStackComplete } = options;
+        const startTime = Date.now();
+        let lastStatus;
+        let stackComplete = false;
+        let stackSuccess = false;
+        let failureReason;
+        logger.debug("CloudFormation", "waitForStackComplete called", {
+            stackName,
+            timeout,
+            pollInterval,
+            hasOnResourceUpdate: !!onResourceUpdate
+        });
+        await this.startMonitoring(stackName, (event) => {
+            if (onResourceUpdate) {
+                onResourceUpdate(event);
+            }
+            if (event.resourceType === "AWS::CloudFormation::Stack" &&
+                event.logicalId === stackName) {
+                lastStatus = event.status;
+                if (this.isTerminalState(event.status)) {
+                    stackComplete = true;
+                    stackSuccess = this.isSuccessState(event.status);
+                    if (!stackSuccess) {
+                        failureReason =
+                            this.getFirstFailureReason() ||
+                                event.statusReason ||
+                                "Stack operation failed";
+                    }
+                }
+            }
+        }, (success, message) => {
+            if (onStackComplete) {
+                onStackComplete(success, message);
+            }
+        });
+        try {
+            let hasSeenStackEvents = false;
+            let noEventWarningShown = false;
+            while (!stackComplete &&
+                this.isMonitoring &&
+                Date.now() - startTime < timeout) {
+                await sleep(pollInterval);
+                if (!hasSeenStackEvents &&
+                    Date.now() - startTime > 30000 &&
+                    !noEventWarningShown) {
+                    noEventWarningShown = true;
+                    const stackStatus = await this.getStackStatus(stackName);
+                    if (!stackStatus) {
+                        // Stack doesn't exist yet - CDK may still be uploading assets
+                        // (e.g. Lambda deployment packages). Don't break - CDK result is
+                        // the source of truth; keep waiting for the stack to appear.
+                        logger.debug("CloudFormation", "Stack not found after 30s, continuing to wait (CDK may be uploading assets)", { stackName });
+                    }
+                }
+                if (lastStatus) {
+                    hasSeenStackEvents = true;
+                }
+            }
+            this.stopMonitoring();
+            if (!stackComplete) {
+                if (failureReason) {
+                    return {
+                        success: false,
+                        status: "FAILED",
+                        failureReason: failureReason,
+                        logPath: this.getLogSummary() || undefined
+                    };
+                }
+                const finalStatus = await this.getStackStatus(stackName);
+                return {
+                    success: false,
+                    status: finalStatus?.status || "UNKNOWN",
+                    failureReason: `Deployment timed out after ${timeout / 1000} seconds. Stack status: ${finalStatus?.status || "UNKNOWN"}`,
+                    logPath: this.getLogSummary() || undefined
+                };
+            }
+            return {
+                success: stackSuccess,
+                status: lastStatus,
+                failureReason: failureReason,
+                logPath: this.getLogSummary() || undefined
+            };
+        }
+        catch (error) {
+            this.stopMonitoring();
+            return {
+                success: false,
+                failureReason: `Monitoring error: ${getErrorMessage(error)}`,
+                logPath: this.getLogSummary() || undefined
+            };
+        }
+    }
+    isTerminalState(status) {
+        return [
+            "CREATE_COMPLETE",
+            "CREATE_FAILED",
+            "DELETE_COMPLETE",
+            "DELETE_FAILED",
+            "UPDATE_COMPLETE",
+            "UPDATE_FAILED",
+            "UPDATE_ROLLBACK_COMPLETE",
+            "UPDATE_ROLLBACK_FAILED",
+            "ROLLBACK_COMPLETE",
+            "ROLLBACK_FAILED",
+            "IMPORT_COMPLETE",
+            "IMPORT_ROLLBACK_COMPLETE",
+            "IMPORT_ROLLBACK_FAILED"
+        ].includes(status);
+    }
+    isSuccessState(status) {
+        return [
+            "CREATE_COMPLETE",
+            "UPDATE_COMPLETE",
+            "DELETE_COMPLETE",
+            "IMPORT_COMPLETE"
+        ].includes(status);
+    }
+    async pollEvents(stackName, onResourceUpdate) {
+        try {
+            const client = this.aws.getClient(CloudFormationClient);
+            let nextToken;
+            let stackComplete = false;
+            let reachedSeenEvents = false;
+            do {
+                const command = new DescribeStackEventsCommand({
+                    StackName: stackName,
+                    ...(nextToken ? { NextToken: nextToken } : {})
+                });
+                const response = await client.send(command);
+                if (!response.StackEvents) {
+                    break;
+                }
+                for (const event of response.StackEvents) {
+                    const eventId = `${event.EventId}`;
+                    if (this.seenEventIds.has(eventId)) {
+                        // Events are returned newest-first; a seen event means all
+                        // remaining events on this page (and subsequent pages) are older
+                        // and already processed — stop paginating after this page.
+                        // Skip processing (including terminal-state checks) for already-seen events.
+                        reachedSeenEvents = true;
+                        continue;
+                    }
+                    this.seenEventIds.add(eventId);
+                    if (event.ResourceType === "AWS::CloudFormation::Stack" &&
+                        event.LogicalResourceId !== stackName) {
+                        const status = event.ResourceStatus || "";
+                        const nestedStackId = event.LogicalResourceId || "";
+                        if (status.includes("IN_PROGRESS")) {
+                            this.activeNestedStacks.set(nestedStackId, status);
+                        }
+                        else if (status.includes("COMPLETE") ||
+                            status.includes("FAILED")) {
+                            this.activeNestedStacks.delete(nestedStackId);
+                        }
+                    }
+                    if (event.LogicalResourceId === stackName &&
+                        event.ResourceType === "AWS::CloudFormation::Stack") {
+                        const status = event.ResourceStatus || "";
+                        if (status === "DELETE_COMPLETE") {
+                            stackComplete = true;
+                        }
+                        else if (status === "CREATE_COMPLETE" ||
+                            status === "UPDATE_COMPLETE") {
+                            stackComplete = true;
+                        }
+                        else if (status === "CREATE_FAILED" ||
+                            status === "UPDATE_FAILED" ||
+                            status === "DELETE_FAILED" ||
+                            status === "ROLLBACK_COMPLETE" ||
+                            status === "UPDATE_ROLLBACK_COMPLETE") {
+                            stackComplete = true;
+                        }
+                    }
+                    if (event.ResourceStatus &&
+                        event.ResourceStatus.includes("FAILED") &&
+                        event.ResourceStatusReason) {
+                        this.failureReasons.set(event.LogicalResourceId || "unknown", event.ResourceStatusReason);
+                        // Log failure details for debugging
+                        logger.debug("CloudFormation", `Captured failure: ${event.LogicalResourceId} - ${event.ResourceStatusReason}`);
+                    }
+                    const resourceEvent = {
+                        logicalId: event.LogicalResourceId || "",
+                        physicalId: event.PhysicalResourceId,
+                        resourceType: event.ResourceType || "",
+                        status: event.ResourceStatus || "",
+                        statusReason: event.ResourceStatusReason,
+                        timestamp: event.Timestamp || new Date()
+                    };
+                    const logicalId = resourceEvent.logicalId;
+                    const history = this.eventHistory.get(logicalId) ?? [];
+                    history.push(resourceEvent);
+                    this.eventHistory.set(logicalId, history);
+                    // Enforce maxHistorySize to prevent memory leaks during long deployments
+                    if (this.eventHistory.size > this.maxHistorySize) {
+                        const keysToDelete = [...this.eventHistory.keys()].slice(0, this.eventHistory.size - this.maxHistorySize);
+                        for (const key of keysToDelete) {
+                            this.eventHistory.delete(key);
+                        }
+                    }
+                    // IPAM concurrency tracking — logs which IPAM pools/CIDRs are in-flight
+                    // simultaneously, critical for diagnosing "too many concurrent mutations"
+                    if (resourceEvent.resourceType === "AWS::EC2::IPAMPool" ||
+                        resourceEvent.resourceType === "AWS::EC2::IPAMPoolCidr" ||
+                        resourceEvent.resourceType === "AWS::EC2::IPAM") {
+                        if (resourceEvent.status.includes("IN_PROGRESS")) {
+                            this.ipamInProgress.set(resourceEvent.logicalId, {
+                                resourceType: resourceEvent.resourceType,
+                                startTime: resourceEvent.timestamp
+                            });
+                            const concurrent = Array.from(this.ipamInProgress.entries()).map(([id, info]) => `${id} (${info.resourceType.split("::").pop()}, started ${info.startTime.toISOString()})`);
+                            logger.debug("CloudFormation", "IPAM resource started", {
+                                logicalId: resourceEvent.logicalId,
+                                resourceType: resourceEvent.resourceType,
+                                concurrentIpamCount: this.ipamInProgress.size,
+                                concurrentIpamResources: concurrent
+                            });
+                            if (this.eventLogger) {
+                                this.eventLogger.writeEvent(resourceEvent, {
+                                    phase: "ipam_concurrency",
+                                    isMainStack: true,
+                                    parentStack: `concurrent=${this.ipamInProgress.size}: ${concurrent.join(", ")}`
+                                });
+                            }
+                        }
+                        else if (resourceEvent.status.includes("COMPLETE") ||
+                            resourceEvent.status.includes("FAILED")) {
+                            const wasInProgress = this.ipamInProgress.has(resourceEvent.logicalId);
+                            const startInfo = this.ipamInProgress.get(resourceEvent.logicalId);
+                            this.ipamInProgress.delete(resourceEvent.logicalId);
+                            const durationMs = startInfo
+                                ? resourceEvent.timestamp.getTime() -
+                                    startInfo.startTime.getTime()
+                                : undefined;
+                            logger.debug("CloudFormation", `IPAM resource ${resourceEvent.status}`, {
+                                logicalId: resourceEvent.logicalId,
+                                resourceType: resourceEvent.resourceType,
+                                status: resourceEvent.status,
+                                statusReason: resourceEvent.statusReason,
+                                durationMs,
+                                wasTracked: wasInProgress,
+                                remainingIpamCount: this.ipamInProgress.size,
+                                remainingIpamResources: Array.from(this.ipamInProgress.keys())
+                            });
+                            if (resourceEvent.status.includes("FAILED") && this.eventLogger) {
+                                // Snapshot all in-flight IPAM resources at failure time
+                                const snapshot = Array.from(this.ipamInProgress.entries()).map(([id, info]) => ({
+                                    logicalId: id,
+                                    resourceType: info.resourceType,
+                                    startTime: info.startTime.toISOString(),
+                                    inFlightDurationMs: resourceEvent.timestamp.getTime() -
+                                        info.startTime.getTime()
+                                }));
+                                this.eventLogger.writeEvent(resourceEvent, {
+                                    phase: "ipam_failure_snapshot",
+                                    isMainStack: true,
+                                    parentStack: JSON.stringify({
+                                        failedResource: resourceEvent.logicalId,
+                                        reason: resourceEvent.statusReason,
+                                        durationMs,
+                                        concurrentIpamAtFailure: snapshot
+                                    })
+                                });
+                            }
+                        }
+                    }
+                    if (this.eventLogger) {
+                        this.eventLogger.writeEvent(resourceEvent);
+                    }
+                    logger.debug("CloudFormation", "pollEvents delivering event", {
+                        stackName,
+                        logicalId: resourceEvent.logicalId,
+                        status: resourceEvent.status,
+                        resourceType: resourceEvent.resourceType
+                    });
+                    onResourceUpdate(resourceEvent);
+                }
+                nextToken = reachedSeenEvents ? undefined : response.NextToken;
+            } while (nextToken);
+            if (stackComplete && this.activeNestedStacks.size > 0) {
+                return false;
+            }
+            return stackComplete;
+        }
+        catch (error) {
+            const errorName = typeof error === "object" &&
+                error !== null &&
+                "name" in error &&
+                typeof error.name === "string"
+                ? error.name
+                : undefined;
+            const errorMessage = getErrorMessage(error);
+            if (errorName === "ValidationError" &&
+                errorMessage.includes(STACK_NOT_FOUND_PATTERN)) {
+                return false;
+            }
+            if (errorName === "Throttling" ||
+                errorName === "TooManyRequestsException" ||
+                errorName === "ThrottlingException") {
+                return "throttled";
+            }
+            if (!errorMessage.includes(STACK_NOT_FOUND_PATTERN)) {
+                logger.error("CloudFormation", "Unexpected polling error", {
+                    error: maskSensitiveOutput(errorMessage)
+                });
+            }
+            return false;
+        }
+    }
+    async getStackStatus(stackName) {
+        try {
+            const command = new DescribeStacksCommand({
+                StackName: stackName
+            });
+            const client = this.aws.getClient(CloudFormationClient);
+            const response = await client.send(command);
+            if (response.Stacks && response.Stacks.length > 0) {
+                const stack = response.Stacks[0];
+                return {
+                    status: stack.StackStatus || "UNKNOWN",
+                    statusReason: stack.StackStatusReason
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            logger.debug("CloudFormation", "getStackStatus failed", {
+                error: getErrorMessage(error)
+            });
+            return null;
+        }
+    }
+    async getCurrentResources(stackName) {
+        const resources = [];
+        try {
+            const command = new DescribeStackEventsCommand({
+                StackName: stackName
+            });
+            const client = this.aws.getClient(CloudFormationClient);
+            const response = await client.send(command);
+            if (!response.StackEvents) {
+                return resources;
+            }
+            const resourceMap = new Map();
+            for (const event of response.StackEvents) {
+                const logicalId = event.LogicalResourceId || "";
+                if (logicalId === stackName &&
+                    event.ResourceType === "AWS::CloudFormation::Stack") {
+                    continue;
+                }
+                const existing = resourceMap.get(logicalId);
+                if (!existing ||
+                    (event.Timestamp && existing.timestamp < event.Timestamp)) {
+                    resourceMap.set(logicalId, {
+                        logicalId,
+                        physicalId: event.PhysicalResourceId,
+                        resourceType: event.ResourceType || "",
+                        status: event.ResourceStatus || "",
+                        statusReason: event.ResourceStatusReason,
+                        timestamp: event.Timestamp || new Date()
+                    });
+                }
+            }
+            return Array.from(resourceMap.values());
+        }
+        catch (error) {
+            const errorName = typeof error === "object" &&
+                error !== null &&
+                "name" in error &&
+                typeof error.name === "string"
+                ? error.name
+                : undefined;
+            const errorMessage = getErrorMessage(error);
+            if (errorName === "ValidationError" &&
+                errorMessage.includes(STACK_NOT_FOUND_PATTERN)) {
+                return resources;
+            }
+            if (!errorMessage.includes(STACK_NOT_FOUND_PATTERN)) {
+                logger.error("CloudFormation", "Error getting current resources", {
+                    error: maskSensitiveOutput(getErrorMessage(error))
+                });
+            }
+            return resources;
+        }
+    }
+}

package/dist/src/aws/utils/errors.d.ts

@@ -0,0 +1,26 @@
+export declare class AWSError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class NoRolesFoundError extends AWSError {
+    constructor(accountId?: string);
+}
+export declare class InvalidCredentialsError extends AWSError {
+    constructor(message: string);
+}
+export declare class SSOTokenExpiredError extends AWSError {
+    constructor();
+}
+export declare class MissingRegionError extends AWSError {
+    constructor();
+}
+export declare class ProfileNotFoundError extends AWSError {
+    constructor(profileName: string);
+}
+export declare function isAWSError(error: unknown): error is AWSError;
+export declare function isNoRolesFoundError(error: unknown): error is NoRolesFoundError;
+export declare function isSSOUnauthorizedError(error: unknown): boolean;
+export declare class CommandError extends AWSError {
+    readonly tip?: string;
+    constructor(message: string, tip?: string);
+}

package/dist/src/aws/utils/errors.js

@@ -0,0 +1,59 @@
+export class AWSError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class NoRolesFoundError extends AWSError {
+    constructor(accountId) {
+        const message = accountId
+            ? `No roles found for account ${accountId}`
+            : "No roles found for this account";
+        super(message, "NO_ROLES_FOUND");
+    }
+}
+export class InvalidCredentialsError extends AWSError {
+    constructor(message) {
+        super(message, "INVALID_CREDENTIALS");
+    }
+}
+export class SSOTokenExpiredError extends AWSError {
+    constructor() {
+        super("SSO token has expired", "SSO_TOKEN_EXPIRED");
+    }
+}
+export class MissingRegionError extends AWSError {
+    constructor() {
+        super("Region is missing in AWS configuration and environment", "MISSING_REGION");
+    }
+}
+export class ProfileNotFoundError extends AWSError {
+    constructor(profileName) {
+        super(`AWS profile '${profileName}' not found`, "PROFILE_NOT_FOUND");
+    }
+}
+export function isAWSError(error) {
+    return error instanceof AWSError;
+}
+export function isNoRolesFoundError(error) {
+    return error instanceof NoRolesFoundError;
+}
+export function isSSOUnauthorizedError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    return (("name" in error && error.name === "UnauthorizedException") ||
+        ("Code" in error && error.Code === "UnauthorizedException") ||
+        ("__type" in error &&
+            typeof error.__type === "string" &&
+            error.__type.includes("UnauthorizedException")));
+}
+export class CommandError extends AWSError {
+    tip;
+    constructor(message, tip) {
+        super(message, "COMMAND_ERROR");
+        this.tip = tip;
+    }
+}

package/dist/src/aws/utils/regions.d.ts

@@ -0,0 +1 @@
+export { type RegionInfo, DEFAULT_REGION, regions, AWS_REGIONS_METADATA, topRegions, commonRegions, parseRegionList, isValidRegion, isValidRegionFormat, getSuggestions, validateRegion, validateRegionList, filterDuplicateRegions, getRegionOptions, getRegionOptionsExcluding, getRegionName, createRegionFormatter } from "@fjall/generator";