@fjall/deploy-core 0.89.2

package/dist/src/services/infrastructure/CdkCommandRunner.js

@@ -0,0 +1,241 @@
+import { tmpdir } from "os";
+import { logger } from "@fjall/util";
+import { success, failure } from "@fjall/generator";
+import { CdkError } from "../../types/errors/CdkError.js";
+import { DEFAULT_REGION } from "../../aws/utils/regions.js";
+import { isCdkError, formatInfrastructureError } from "./CdkErrorFormatter.js";
+import { hasCdkDifferences, parseDiffOutput } from "./CdkOutputParser.js";
+import { CdkArgumentBuilder } from "./CdkArgumentBuilder.js";
+import { CdkProcessManager } from "./CdkProcessManager.js";
+import { DEFAULT_DEPLOY_TIMEOUT_MS } from "./CdkEventMonitoring.js";
+import { analyseBootstrapError } from "./CdkOutputAnalyser.js";
+/** Synth is CPU-bound template generation — 5 minutes is generous */
+const SYNTH_TIMEOUT_MS = 300_000;
+/** Bootstrap creates a single stack with a handful of resources */
+const BOOTSTRAP_TIMEOUT_MS = 180_000;
+/** Import maps existing resources into CDK state — slower than deploy due to resource lookup */
+const IMPORT_TIMEOUT_MS = 1_200_000;
+/** CDK flags used across multiple commands */
+const CDK_FLAGS = Object.freeze({
+    CI: "--ci",
+    REQUIRE_APPROVAL: "--require-approval",
+    APPROVAL_NEVER: "never",
+    VERBOSE: "--verbose",
+    NO_LOOKUPS: "--no-lookups",
+    ALL: "--all"
+});
+/**
+ * Runs low-level CDK CLI commands (synth, deploy, destroy, diff, bootstrap, import).
+ * Delegates process management to CdkProcessManager.
+ */
+export class CdkCommandRunner {
+    processManager;
+    constructor() {
+        const argBuilder = new CdkArgumentBuilder();
+        this.processManager = new CdkProcessManager(argBuilder);
+    }
+    async checkDifferences(path, stackName, options) {
+        const args = ["diff"];
+        if (stackName) {
+            args.push(stackName);
+        }
+        else {
+            args.push(CDK_FLAGS.ALL);
+        }
+        // Add no-colour flag for cleaner parsing
+        args.push("--no-color");
+        if (options?.noLookups) {
+            args.push(CDK_FLAGS.NO_LOOKUPS);
+        }
+        const result = await this.processManager.runCdkCommand(path, args, {
+            ...options,
+            // Diff command returns non-zero if differences exist
+            ignoreExitCode: true
+        });
+        if (!result.success) {
+            return failure(new CdkError(formatInfrastructureError(result.error, path), "diff_failed", undefined, undefined, result.error, undefined, false));
+        }
+        const output = result.data.output || "";
+        // Check if the output indicates an error rather than a successful diff
+        if (isCdkError(output)) {
+            return failure(new CdkError(formatInfrastructureError(output, path), "diff_failed", undefined, undefined, output, undefined, false));
+        }
+        const hasDiffs = hasCdkDifferences(output);
+        const details = parseDiffOutput(output);
+        return success({
+            hasDifferences: hasDiffs,
+            output,
+            details
+        });
+    }
+    async deploy(path, stackName, options) {
+        const args = ["deploy"];
+        if (options?.appDir) {
+            args.push("--app", options.appDir);
+        }
+        else if (options?.useCdkOut) {
+            args.push("--app", "cdk.out");
+        }
+        if (stackName) {
+            args.push(stackName);
+        }
+        else {
+            args.push(CDK_FLAGS.ALL);
+        }
+        // Never require approval in programmatic mode
+        args.push(CDK_FLAGS.REQUIRE_APPROVAL, CDK_FLAGS.APPROVAL_NEVER);
+        args.push(CDK_FLAGS.CI);
+        // Disable version reporting and metadata for cleaner output
+        args.push("--no-version-reporting");
+        args.push("--no-path-metadata");
+        args.push("--no-asset-metadata");
+        if (options?.verbose) {
+            args.push(CDK_FLAGS.VERBOSE);
+        }
+        else {
+            args.push("--progress", "events");
+        }
+        const deployOptions = {
+            ...options,
+            timeout: options?.timeout || DEFAULT_DEPLOY_TIMEOUT_MS
+        };
+        if (options?.passThroughCDK) {
+            return this.processManager.runCdkCommandPassthrough(path, args, deployOptions);
+        }
+        return this.processManager.runCdkCommand(path, args, deployOptions);
+    }
+    async destroy(path, stackName, options) {
+        const args = ["destroy"];
+        if (options?.appDir) {
+            args.push("--app", options.appDir);
+        }
+        else if (options?.useCdkOut) {
+            args.push("--app", "cdk.out");
+        }
+        if (stackName) {
+            args.push(stackName);
+        }
+        else {
+            args.push(CDK_FLAGS.ALL);
+        }
+        args.push("--force");
+        if (options?.verbose) {
+            args.push(CDK_FLAGS.VERBOSE);
+        }
+        const destroyOptions = {
+            ...options,
+            timeout: options?.timeout || DEFAULT_DEPLOY_TIMEOUT_MS
+        };
+        return this.processManager.runCdkCommand(path, args, destroyOptions);
+    }
+    /**
+     * Import existing AWS resources into CDK stack
+     *
+     * NOTE: This method is fully functional but currently unreachable as import
+     * functionality is temporarily disabled at the AST layer (astCodeModification.ts).
+     * When import is re-enabled, this method will work without changes.
+     */
+    async runImport(path, resourceMappingFile, options) {
+        const args = ["import"];
+        if (options?.stacks && options.stacks.length > 0) {
+            args.push(...options.stacks);
+        }
+        if (resourceMappingFile) {
+            args.push("--resource-mapping", resourceMappingFile);
+        }
+        args.push(CDK_FLAGS.REQUIRE_APPROVAL, CDK_FLAGS.APPROVAL_NEVER);
+        args.push(CDK_FLAGS.CI);
+        if (options?.noLookups) {
+            args.push(CDK_FLAGS.NO_LOOKUPS);
+        }
+        if (options?.verbose) {
+            args.push(CDK_FLAGS.VERBOSE);
+            args.push("--trace");
+            args.push("--debug");
+        }
+        const importOptions = {
+            ...options,
+            timeout: options?.timeout || IMPORT_TIMEOUT_MS
+        };
+        if (options?.passThroughCDK) {
+            return this.processManager.runCdkCommandPassthrough(path, args, importOptions);
+        }
+        return this.processManager.runCdkCommand(path, args, importOptions);
+    }
+    async synth(path, options) {
+        options?.outputCallback?.("Synthesising CloudFormation template...\n");
+        const lookupArgs = options?.noLookups
+            ? [CDK_FLAGS.NO_LOOKUPS]
+            : [];
+        const outputArgs = options?.outputDir
+            ? ["--output", options.outputDir]
+            : [];
+        const region = options?.context?.region || DEFAULT_REGION;
+        const result = await this.processManager.runCdkCommand(path, ["synth", ...lookupArgs, ...outputArgs, CDK_FLAGS.CI, "--quiet"], {
+            ...options,
+            context: { ...options?.context, region },
+            timeout: options?.timeout || SYNTH_TIMEOUT_MS
+        });
+        if (!result.success) {
+            const formatted = result.error
+                ? formatInfrastructureError(result.error, path)
+                : "Failed to synthesise CloudFormation template";
+            return failure(formatted);
+        }
+        return result;
+    }
+    async bootstrap(accountId, region, options) {
+        const bootstrapPath = tmpdir();
+        logger.debug("CdkService", "Starting CDK bootstrap", {
+            accountId,
+            region,
+            bootstrapPath,
+            target: `aws://${accountId}/${region}`
+        });
+        const result = await this.processManager.runCdkCommand(bootstrapPath, [
+            "bootstrap",
+            `aws://${accountId}/${region}`,
+            "--cloudformation-execution-policies",
+            "arn:aws:iam::aws:policy/AdministratorAccess",
+            "-c",
+            `accountId=${accountId}`,
+            CDK_FLAGS.REQUIRE_APPROVAL,
+            CDK_FLAGS.APPROVAL_NEVER,
+            CDK_FLAGS.CI,
+            "--quiet",
+            "--force"
+        ], {
+            ...options,
+            timeout: options?.timeout || BOOTSTRAP_TIMEOUT_MS,
+            context: { region, accountId },
+            credentials: options?.credentials,
+            skipProjectCheck: true,
+            extraEnv: {
+                TERM: "dumb",
+                CDK_DISABLE_NOTICES: "true",
+                CDK_DISABLE_PROGRESS_BAR: "true"
+            }
+        });
+        logger.debug("CdkService", result.success
+            ? "Bootstrap completed successfully"
+            : "Bootstrap exited with non-zero code", {
+            accountId,
+            region,
+            exitCode: result.success ? result.data.exitCode : undefined,
+            output: result.success
+                ? result.data.output?.trim() || "(empty)"
+                : "(empty)",
+            error: result.success ? "(empty)" : result.error.trim() || "(empty)"
+        });
+        if (!result.success) {
+            if (result.error.includes("already bootstrapped")) {
+                return success({
+                    output: "Environment is already bootstrapped",
+                    exitCode: 0
+                });
+            }
+            return failure(analyseBootstrapError(result.error));
+        }
+        return success({ output: "AWS environment bootstrapped", exitCode: 0 });
+    }
+}

package/dist/src/services/infrastructure/CdkErrorFormatter.d.ts

@@ -0,0 +1,4 @@
+export declare function isCdkError(output: string): boolean;
+export declare function getStructuralHint(tsCode: string): string | null;
+export declare function getSourceContext(filePath: string, lineNumber: number, contextLines?: number): string | null;
+export declare function formatInfrastructureError(output: string, appPath?: string): string;

package/dist/src/services/infrastructure/CdkErrorFormatter.js

@@ -0,0 +1,194 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+const CDK_ERROR_PATTERNS = [
+    // Authentication and credentials errors
+    /Unable to locate credentials/i,
+    /ExpiredToken/i,
+    /InvalidUserPool/i,
+    /AccessDenied/i,
+    /UnauthorizedAccess/i,
+    /AssumeRoleUnauthorizedAccess/i,
+    /The security token included in the request is invalid/i,
+    /Could not assume role/i,
+    // Bootstrap errors
+    /This stack uses assets, so the toolkit stack must be deployed/i,
+    /Has the environment been bootstrapped/i,
+    /Please run 'cdk bootstrap'/i,
+    /requires a newer version of the CDK CLI/i,
+    // Stack not found errors
+    /Stack .* does not exist/i,
+    /Unable to resolve AWS account/i,
+    // General CDK errors
+    /ENOENT.*cdk\.json/i,
+    /Cannot find module/i,
+    /SyntaxError:/i,
+    /TypeError:/i,
+    /ReferenceError:/i,
+    /Error: /i,
+    // Common failure messages
+    /❌ .*failed/i,
+    /\[ERROR\]/i,
+    /fatal:/i
+];
+const STRUCTURAL_HINTS = {
+    TS1005: "Check for missing or extra brackets, braces, or commas",
+    TS1135: "Check for mismatched brackets or braces — a common cause is extra `},` or `]` characters",
+    TS1136: "Check for mismatched braces in object literals",
+    TS1109: "Check for extra commas or mismatched delimiters",
+    TS1003: "Check for syntax errors near the indicated position"
+};
+export function isCdkError(output) {
+    if (!output)
+        return false;
+    return CDK_ERROR_PATTERNS.some((pattern) => pattern.test(output));
+}
+export function getStructuralHint(tsCode) {
+    return STRUCTURAL_HINTS[tsCode] ?? null;
+}
+export function getSourceContext(filePath, lineNumber, contextLines = 1) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const start = Math.max(0, lineNumber - 1 - contextLines);
+        const end = Math.min(lines.length, lineNumber + contextLines);
+        const gutterWidth = String(end).length;
+        const formatted = [];
+        for (let i = start; i < end; i++) {
+            const num = String(i + 1).padStart(gutterWidth);
+            const marker = i === lineNumber - 1 ? ">" : " ";
+            formatted.push(`${marker} ${num} | ${lines[i]}`);
+        }
+        return formatted.join("\n");
+    }
+    catch {
+        // File not readable — skip source context display
+        return null;
+    }
+}
+export function formatInfrastructureError(output, appPath) {
+    const lines = output.split("\n");
+    // Handle TypeScript compilation errors
+    if (output.includes("error TS")) {
+        const tsErrorRegex = /([\w./-]+\.ts)\((\d+),(\d+)\): error (TS\d+): (.+)/;
+        const parsed = [];
+        for (const line of lines) {
+            const match = line.match(tsErrorRegex);
+            if (match) {
+                parsed.push({
+                    file: match[1],
+                    line: parseInt(match[2], 10),
+                    col: parseInt(match[3], 10),
+                    code: match[4],
+                    message: match[5]
+                });
+            }
+        }
+        if (parsed.length > 0) {
+            const seen = new Set();
+            const unique = parsed.filter((e) => {
+                const key = `${e.file}:${e.line}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            });
+            const errors = unique.slice(0, 3);
+            const firstError = errors[0];
+            const parts = [];
+            parts.push(`TypeScript compilation failed in ${firstError.file}:\n`);
+            if (appPath) {
+                const resolvedPath = join(appPath, firstError.file);
+                const context = getSourceContext(resolvedPath, firstError.line);
+                if (context) {
+                    parts.push(context);
+                    parts.push("");
+                }
+            }
+            for (const err of errors) {
+                parts.push(`Error on line ${err.line}: ${err.message} (${err.code})`);
+                const hint = getStructuralHint(err.code);
+                if (hint) {
+                    parts.push(`Hint: ${hint}`);
+                }
+            }
+            return parts.join("\n");
+        }
+    }
+    // Handle multi-line CDK validation errors
+    const multiLineValidationMatch = output.match(/Validation failed with the following errors:([\s\S]*?)(?=\n\s*at\s|\n\n|$)/);
+    if (multiLineValidationMatch) {
+        const errorLines = multiLineValidationMatch[1]
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0);
+        return `Validation failed with the following errors:\n${errorLines.map((l) => `  ${l}`).join("\n")}`;
+    }
+    // Handle CDK ValidationError (e.g., missing asset directories)
+    const validationMatch = output.match(/ValidationError:\s*(.+?)(?:\n|$)/);
+    if (validationMatch) {
+        const detail = validationMatch[1];
+        const constructMatch = output.match(/at path \[([^\]]+)\] in ([\w.-]+)/);
+        let formatted = `${detail}`;
+        if (constructMatch) {
+            formatted += `\nConstruct: ${constructMatch[1]}`;
+        }
+        if (detail.includes("Cannot find asset")) {
+            const assetPath = detail.match(/at (.+)/)?.[1];
+            if (assetPath) {
+                formatted += `\nHint: The build output directory does not exist. Make sure the build step has completed before deploying`;
+            }
+        }
+        return formatted;
+    }
+    // Try to extract: file path, code snippet, error type/message
+    let fileLine = "";
+    let codeSnippet = "";
+    let pointer = "";
+    let errorMessage = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fileMatch = line.match(/^(\/[^:]+\.ts):(\d+)/);
+        if (fileMatch && !fileLine) {
+            const fullPath = fileMatch[1];
+            const lineNum = fileMatch[2];
+            const fileName = fullPath.split("/").pop() || fullPath;
+            fileLine = `${fileName}:${lineNum}`;
+            if (i + 1 < lines.length) {
+                codeSnippet = lines[i + 1];
+            }
+            if (i + 2 < lines.length && lines[i + 2].includes("^")) {
+                pointer = lines[i + 2];
+            }
+        }
+        const errorMatch = line.match(/^(\w*Error):\s*(.+)/);
+        if (errorMatch && !errorMessage) {
+            errorMessage = `${errorMatch[1]}: ${errorMatch[2]}`;
+        }
+    }
+    if (fileLine && errorMessage) {
+        let formatted = `Error in ${fileLine}\n`;
+        if (codeSnippet) {
+            formatted += `${codeSnippet}\n`;
+        }
+        if (pointer) {
+            formatted += `${pointer}\n`;
+        }
+        formatted += `\n${errorMessage}`;
+        return formatted;
+    }
+    if (errorMessage) {
+        return errorMessage;
+    }
+    // Fallback: return first few meaningful lines, filtering out noise
+    const meaningfulLines = lines
+        .filter((l) => l.trim() &&
+        l.length < 500 &&
+        !l.includes("at Module.") &&
+        !l.includes("at Object.") &&
+        !l.includes("at Function.") &&
+        !l.includes("node:internal") &&
+        !l.includes("node_modules/ts-node") &&
+        !l.includes("node_modules/aws-cdk"))
+        .slice(0, 5);
+    return meaningfulLines.join("\n") || output;
+}

package/dist/src/services/infrastructure/CdkEventMonitoring.d.ts

@@ -0,0 +1,19 @@
+import { type ResourceEvent, type CloudFormationEventMonitor } from "../../aws/utils/cloudformationEvents.js";
+import type { DeploymentContext } from "../../types/deployment/DeploymentTypes.js";
+import type { AwsProvider } from "../../aws/AwsProvider.js";
+import type { EventLogWriterFactory } from "../../aws/utils/cloudformationEvents.js";
+/** Deploy/destroy default — CloudFormation stacks can take up to 30 minutes */
+export declare const DEFAULT_DEPLOY_TIMEOUT_MS = 1800000;
+export declare function startStackMonitoring(monitor: CloudFormationEventMonitor, stackName: string, onResourceProgress?: (event: ResourceEvent) => void): Promise<{
+    success: boolean;
+    status?: string;
+    failureReason?: string;
+    logPath?: string;
+}>;
+export declare class CdkEventMonitor {
+    private eventLogWriterFactory?;
+    constructor(options?: {
+        eventLogWriterFactory?: EventLogWriterFactory;
+    });
+    createEventMonitor(operation: "deploy" | "destroy", stackName: string, region: string, context: DeploymentContext, aws: AwsProvider): Promise<CloudFormationEventMonitor>;
+}

package/dist/src/services/infrastructure/CdkEventMonitoring.js

@@ -0,0 +1,41 @@
+import { logger, getErrorMessage } from "@fjall/util";
+import { CloudFormationFailureAnalyser } from "../../aws/utils/CloudFormationFailureAnalyser.js";
+/** Deploy/destroy default — CloudFormation stacks can take up to 30 minutes */
+export const DEFAULT_DEPLOY_TIMEOUT_MS = 1_800_000;
+export function startStackMonitoring(monitor, stackName, onResourceProgress) {
+    return monitor
+        .waitForStackComplete(stackName, {
+        timeout: DEFAULT_DEPLOY_TIMEOUT_MS,
+        pollInterval: 2000,
+        onResourceUpdate: onResourceProgress,
+        onStackComplete: (_success, _message) => {
+            // Stack deployment completed — no console output per architecture
+        }
+    })
+        .catch((err) => {
+        logger.debug("CdkService", "Stack monitoring failed", {
+            error: getErrorMessage(err)
+        });
+        return {
+            success: false,
+            failureReason: "Monitoring failed"
+        };
+    });
+}
+export class CdkEventMonitor {
+    eventLogWriterFactory;
+    constructor(options) {
+        this.eventLogWriterFactory = options?.eventLogWriterFactory;
+    }
+    async createEventMonitor(operation, stackName, region, context, aws) {
+        const cloudFormationEventsModule = await import("../../aws/utils/cloudformationEvents.js");
+        const monitor = new cloudFormationEventsModule.CloudFormationEventMonitor(aws, {
+            failureAnalyser: new CloudFormationFailureAnalyser(),
+            eventLogWriterFactory: this.eventLogWriterFactory
+        });
+        const deploymentId = `${operation}-${Date.now()}`;
+        const deploymentName = context.target || context.deployType || "deployment";
+        monitor.enableLogging(deploymentId, stackName, region, deploymentName);
+        return monitor;
+    }
+}

package/dist/src/services/infrastructure/CdkOutputAnalyser.d.ts

@@ -0,0 +1,43 @@
+import { type ResourceEvent, type CloudFormationEventMonitor } from "../../aws/utils/cloudformationEvents.js";
+import type { StepOutput } from "../../types/deployment/DeploymentTypes.js";
+import type { Result } from "@fjall/generator";
+import type { CdkOutput } from "./CdkService.js";
+/**
+ * Analyse CDK deploy output and classify the result as success/skip/failure.
+ */
+export declare function analyseDeployOutput(cdkOutput: string, result: Result<CdkOutput, string>, stackName: string): Result<StepOutput, string>;
+/**
+ * Classify a bootstrap error into a user-friendly message.
+ */
+export declare function analyseBootstrapError(errorInfo: string): string;
+/**
+ * Analyse CDK destroy result and classify it.
+ */
+export declare function analyseDestroyResult(result: Result<CdkOutput, string>): Result<StepOutput, string>;
+/** Result of attempting to detect a stack name from a CDK output chunk */
+export interface StackDetectionResult {
+    detected: boolean;
+    stackName?: string;
+}
+/**
+ * Try to detect the actual CloudFormation stack name from a CDK output chunk.
+ * CDK outputs the stack name in several formats during deployment.
+ */
+export declare function detectStackNameFromChunk(chunk: string): StackDetectionResult;
+/** Mutable state container for deploy monitoring, to avoid closure complexity in CdkService */
+export interface DeployMonitoringState {
+    cdkOutput: string;
+    actualStackName: string;
+    stackDetected: boolean;
+    monitoringPromise: Promise<{
+        success: boolean;
+        status?: string;
+        failureReason?: string;
+        logPath?: string;
+    }> | null;
+}
+/**
+ * Create an enhanced output callback that detects the actual stack name from CDK output
+ * and starts CloudFormation monitoring once detected.
+ */
+export declare function createEnhancedOutputCallback(state: DeployMonitoringState, originalOutputCallback: ((chunk: string) => void) | undefined, cfnMonitor: CloudFormationEventMonitor | null, onResourceProgress: ((event: ResourceEvent) => void) | undefined): (chunk: string) => void;

package/dist/src/services/infrastructure/CdkOutputAnalyser.js

@@ -0,0 +1,125 @@
+import { logger } from "@fjall/util";
+import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH } from "../../aws/utils/cloudformationEvents.js";
+import { success, failure } from "@fjall/generator";
+import { formatInfrastructureError } from "./CdkErrorFormatter.js";
+import { startStackMonitoring } from "./CdkEventMonitoring.js";
+/**
+ * Analyse CDK deploy output and classify the result as success/skip/failure.
+ */
+export function analyseDeployOutput(cdkOutput, result, stackName) {
+    const stackSpecificNoResourcesPattern = new RegExp(`${stackName}[:\\s|]*.*?(?:stack has no resources|skipping deployment)`, "i");
+    const hasEmptyStack = stackSpecificNoResourcesPattern.test(cdkOutput);
+    const hasNoChanges = cdkOutput.includes("no changes") ||
+        cdkOutput.includes("Stack is up to date") ||
+        cdkOutput.includes("No changes to deploy");
+    const noStacksMatch = cdkOutput.includes(CDK_NO_STACKS_MATCH) ||
+        (!result.success && result.error.includes(CDK_NO_STACKS_MATCH));
+    if (result.success) {
+        return success({
+            message: hasEmptyStack
+                ? "Stack has no resources, skipped"
+                : hasNoChanges
+                    ? "Infrastructure already up to date"
+                    : "Deployment successful",
+            status: hasNoChanges ? "NO_CHANGES" : undefined,
+            details: { output: cdkOutput, skipped: hasEmptyStack }
+        });
+    }
+    if (noStacksMatch) {
+        return success({
+            message: "Stack not defined, skipped",
+            status: "SKIPPED",
+            details: { output: cdkOutput, skipped: true }
+        });
+    }
+    let errorMessage = result.error || "Deployment failed";
+    if (cdkOutput.includes("failed:")) {
+        const errorMatch = cdkOutput.match(/failed: .*?: (.*?)(?:\n|$)/);
+        if (errorMatch) {
+            errorMessage = errorMatch[1];
+        }
+    }
+    logger.error("CdkService", "CDK deployment returned failure", {
+        errorMessage
+    });
+    return failure(errorMessage);
+}
+/**
+ * Classify a bootstrap error into a user-friendly message.
+ */
+export function analyseBootstrapError(errorInfo) {
+    if (errorInfo.includes("Access Denied") ||
+        errorInfo.includes("AccessDenied")) {
+        return "Access denied. Check your AWS credentials and permissions";
+    }
+    if (errorInfo.includes("ExpiredToken")) {
+        return "AWS credentials have expired. Please refresh your credentials";
+    }
+    if (errorInfo.includes("ENOTFOUND") || errorInfo.includes("ECONNREFUSED")) {
+        return "Network error. Please check your internet connection and try again";
+    }
+    if (errorInfo.includes("timeout")) {
+        return "Bootstrap operation timed out";
+    }
+    return formatInfrastructureError(errorInfo);
+}
+/**
+ * Analyse CDK destroy result and classify it.
+ */
+export function analyseDestroyResult(result) {
+    if (!result.success) {
+        const stackDoesNotExist = result.error.includes(STACK_NOT_FOUND_PATTERN) ||
+            result.error.includes(CDK_NO_STACKS_MATCH);
+        if (stackDoesNotExist) {
+            return success({
+                message: "Stack already deleted or does not exist",
+                details: { skipped: true }
+            });
+        }
+        return failure(result.error || "Destroy failed");
+    }
+    return success({ message: "Stack destroyed successfully" });
+}
+/**
+ * Try to detect the actual CloudFormation stack name from a CDK output chunk.
+ * CDK outputs the stack name in several formats during deployment.
+ */
+export function detectStackNameFromChunk(chunk) {
+    // Pattern 1: "Deploying stack <name>"
+    const deployMatch = chunk.match(/Deploying stack\s+([^\s]+)/);
+    if (deployMatch) {
+        return { detected: true, stackName: deployMatch[1] };
+    }
+    // Pattern 2: "<stack-name> | <number>/<number> |"
+    const progressMatch = chunk.match(/^([^\s|]+)\s*\|\s*\d+\/\d+/m);
+    if (progressMatch) {
+        return { detected: true, stackName: progressMatch[1] };
+    }
+    // Pattern 3: "Stack ARN:" line contains the stack name
+    const arnMatch = chunk.match(/arn:aws:cloudformation:[^:]+:[^:]+:stack\/([^/]+)\//);
+    if (arnMatch) {
+        return { detected: true, stackName: arnMatch[1] };
+    }
+    return { detected: false };
+}
+/**
+ * Create an enhanced output callback that detects the actual stack name from CDK output
+ * and starts CloudFormation monitoring once detected.
+ */
+export function createEnhancedOutputCallback(state, originalOutputCallback, cfnMonitor, onResourceProgress) {
+    return (chunk) => {
+        state.cdkOutput += chunk;
+        originalOutputCallback?.(chunk);
+        if (!state.stackDetected) {
+            const detection = detectStackNameFromChunk(chunk);
+            if (detection.detected && detection.stackName) {
+                state.actualStackName = detection.stackName;
+                state.stackDetected = true;
+            }
+            // Start monitoring once we detect the actual stack name
+            if (state.stackDetected && cfnMonitor && !state.monitoringPromise) {
+                state.monitoringPromise = startStackMonitoring(cfnMonitor, state.actualStackName, onResourceProgress);
+            }
+        }
+    };
+}

package/dist/src/services/infrastructure/CdkOutputParser.d.ts

@@ -0,0 +1,8 @@
+export declare function hasCdkDifferences(output: string | undefined): boolean;
+export interface DiffDetails {
+    hasSecurityChanges: boolean;
+    resourceChanges: number;
+    outputChanges: number;
+    resources: string[];
+}
+export declare function parseDiffOutput(output: string): DiffDetails;