@fjall/deploy-core 0.89.2

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

@@ -0,0 +1,33 @@
+export function hasCdkDifferences(output) {
+    if (!output)
+        return false;
+    // Prefer the summary line: "Number of stacks with differences: 2"
+    const summaryRegex = /Number of stacks with differences:\s*(\d+)/;
+    const summaryMatch = output.match(summaryRegex);
+    if (summaryMatch && summaryMatch[1]) {
+        const diffCount = parseInt(summaryMatch[1], 10);
+        if (!isNaN(diffCount)) {
+            return diffCount > 0;
+        }
+    }
+    // Fallback: if all stacks report "There were no differences" then no changes
+    const allNoDiff = output
+        .split("\n")
+        .filter((l) => l.trim().startsWith("Stack"))
+        .every((l) => l.includes("There were no differences"));
+    return !allNoDiff;
+}
+export function parseDiffOutput(output) {
+    const details = {
+        hasSecurityChanges: output.includes("(requires replacement)") ||
+            output.includes("IAM Statement Changes"),
+        resourceChanges: 0,
+        outputChanges: 0,
+        resources: []
+    };
+    const resourceMatches = output.match(/\[\+\]|\[-\]|\[~\]/g);
+    if (resourceMatches) {
+        details.resourceChanges = resourceMatches.length;
+    }
+    return details;
+}

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

@@ -0,0 +1,20 @@
+import { type ChildProcess } from "child_process";
+import type { Result } from "@fjall/generator";
+import type { CdkOptions, CdkOutput } from "./CdkService.js";
+import { type CdkArgumentBuilder } from "./CdkArgumentBuilder.js";
+export declare class CdkProcessManager {
+    private runningProcesses;
+    private processCounter;
+    private argBuilder;
+    constructor(argBuilder: CdkArgumentBuilder);
+    forceKillProcess(child: ChildProcess): void;
+    cleanup(): void;
+    runCdkCommandPassthrough(workingDir: string, args: string[], options?: CdkOptions & {
+        ignoreExitCode?: boolean;
+    }): Promise<Result<CdkOutput, string>>;
+    runCdkCommand(workingDir: string, args: string[], options?: CdkOptions & {
+        ignoreExitCode?: boolean;
+        skipProjectCheck?: boolean;
+        extraEnv?: Record<string, string>;
+    }): Promise<Result<CdkOutput, string>>;
+}

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

@@ -0,0 +1,244 @@
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+import { filterDangerousEnvVars, maskSensitiveOutput } from "../../util/securityHelpers.js";
+import { logger } from "@fjall/util";
+import { success, failure } from "@fjall/generator";
+import { getErrorMessage } from "@fjall/util";
+/**
+ * Resolve CDK binary path from the caller's node_modules.
+ * Falls back to "npx cdk" only if resolution fails (should never happen
+ * since aws-cdk is a direct dependency of the calling package).
+ */
+function getCdkBinaryPath() {
+    try {
+        const require = createRequire(import.meta.url);
+        const cdkEntry = require.resolve("aws-cdk/bin/cdk");
+        return { command: process.execPath, prefixArgs: [cdkEntry] };
+    }
+    catch {
+        logger.debug("CdkService", "Failed to resolve aws-cdk binary, falling back to npx");
+        return { command: "npx", prefixArgs: ["cdk"] };
+    }
+}
+const cdkBin = getCdkBinaryPath();
+/** Grace period before escalating from SIGTERM to SIGKILL on a stuck CDK process */
+const SIGKILL_GRACE_PERIOD_MS = 5_000;
+export class CdkProcessManager {
+    runningProcesses = new Map();
+    processCounter = 0;
+    argBuilder;
+    constructor(argBuilder) {
+        this.argBuilder = argBuilder;
+        // Register cleanup handlers
+        process.on("exit", () => this.cleanup());
+        process.on("SIGINT", () => {
+            this.cleanup();
+            process.exit(130);
+        });
+        process.on("SIGTERM", () => {
+            this.cleanup();
+            process.exit(143);
+        });
+    }
+    forceKillProcess(child) {
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        child.kill("SIGTERM");
+        setTimeout(() => {
+            if (child.exitCode === null) {
+                child.kill("SIGKILL");
+            }
+        }, SIGKILL_GRACE_PERIOD_MS);
+    }
+    cleanup() {
+        for (const [_name, child] of this.runningProcesses) {
+            if (!child.killed) {
+                child.stdout?.destroy();
+                child.stderr?.destroy();
+                child.kill("SIGTERM");
+            }
+        }
+        this.runningProcesses.clear();
+    }
+    async runCdkCommandPassthrough(workingDir, args, options) {
+        return new Promise((resolve) => {
+            if (!existsSync(workingDir)) {
+                resolve(failure(`Directory not found: ${workingDir}`));
+                return;
+            }
+            // Check for cdk.json in the working directory
+            const cdkJsonPath = join(workingDir, "cdk.json");
+            if (!existsSync(cdkJsonPath)) {
+                resolve(failure(`No CDK project found in ${workingDir}`));
+                return;
+            }
+            const contextArgs = this.argBuilder.buildContextArgs(options?.context);
+            const fullArgs = [...cdkBin.prefixArgs, ...args, ...contextArgs];
+            const env = this.argBuilder.buildCdkEnv(options);
+            // Run CDK with stdio: 'inherit' for direct terminal output
+            const child = spawn(cdkBin.command, fullArgs, {
+                cwd: workingDir,
+                env,
+                stdio: "inherit", // Pass through to terminal directly
+                shell: false,
+                detached: false
+            });
+            // Track process for cleanup
+            const processId = `cdk-passthrough-${Date.now()}`;
+            this.runningProcesses.set(processId, child);
+            // Timeout to prevent indefinite hangs (default 30 minutes, matching deploy)
+            let timeoutHandle;
+            if (options?.timeout) {
+                const timeout = options.timeout;
+                timeoutHandle = setTimeout(() => {
+                    if (!child.killed) {
+                        this.forceKillProcess(child);
+                        this.runningProcesses.delete(processId);
+                        resolve(failure(`CDK command timed out after ${Math.floor(timeout / 60000)} minutes`));
+                    }
+                }, timeout);
+            }
+            child.on("close", (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.runningProcesses.delete(processId);
+                if (code === 0 || options?.ignoreExitCode) {
+                    resolve(success({ exitCode: code || 0 }));
+                }
+                else {
+                    resolve(failure(`CDK command failed with exit code ${code}`));
+                }
+            });
+            child.on("error", (err) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.runningProcesses.delete(processId);
+                resolve(failure(`Failed to run CDK command: ${err.message}`));
+            });
+        });
+    }
+    async runCdkCommand(workingDir, args, options) {
+        return new Promise((resolve) => {
+            if (!existsSync(workingDir)) {
+                resolve(failure(`Directory not found: ${workingDir}`));
+                return;
+            }
+            // Check for cdk.json unless caller explicitly skips (e.g., bootstrap runs from tmpdir)
+            if (!options?.skipProjectCheck) {
+                const cdkJsonPath = join(workingDir, "cdk.json");
+                if (!existsSync(cdkJsonPath)) {
+                    resolve(failure(`No CDK project found in ${workingDir}`));
+                    return;
+                }
+            }
+            let output = "";
+            let errorOutput = "";
+            let processKilled = false;
+            const contextArgs = this.argBuilder.buildContextArgs(options?.context);
+            const fullArgs = [...cdkBin.prefixArgs, ...args, ...contextArgs];
+            const env = {
+                ...this.argBuilder.buildCdkEnv(options),
+                NO_COLOR: "1",
+                ...(options?.extraEnv ? filterDangerousEnvVars(options.extraEnv) : {})
+            };
+            // Try to spawn the CDK process
+            logger.debug("CdkService", "Spawning CDK process", {
+                command: `${cdkBin.command} ${fullArgs.join(" ")}`,
+                workingDir
+            });
+            const child = spawn(cdkBin.command, fullArgs, {
+                cwd: workingDir,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: false,
+                detached: false
+            });
+            // Check if spawn was successful
+            if (!child.pid) {
+                const spawnError = `Failed to spawn CDK process - no PID. cwd=${workingDir}, args=${fullArgs.join(" ")}`;
+                // CRITICAL: Attach error handler to prevent uncaught exception
+                // Node.js emits an async 'error' event on the child process even after spawn fails
+                // If we don't handle it, it becomes an uncaught exception and crashes the app
+                child.on("error", () => {
+                    // Error already handled via the resolve below - this just prevents uncaught exception
+                });
+                resolve(failure(spawnError));
+                return;
+            }
+            // Track process for cleanup
+            const processId = `cdk-${++this.processCounter}`;
+            this.runningProcesses.set(processId, child);
+            let timeoutHandle;
+            if (options?.timeout) {
+                timeoutHandle = setTimeout(() => {
+                    if (!child.killed) {
+                        processKilled = true;
+                        this.forceKillProcess(child);
+                    }
+                }, options.timeout);
+            }
+            child.stdout?.on("data", (data) => {
+                const chunk = data.toString();
+                output += chunk;
+                if (options?.outputCallback) {
+                    options.outputCallback(maskSensitiveOutput(chunk));
+                }
+                options?.cdkOutputLogger?.writeCdkOutput("stdout", maskSensitiveOutput(chunk));
+            });
+            child.stderr?.on("data", (data) => {
+                const chunk = data.toString();
+                options?.cdkOutputLogger?.writeCdkOutput("stderr", maskSensitiveOutput(chunk));
+                // Filter out non-critical warnings from the in-memory error buffer
+                if (!chunk.includes("deprecated") &&
+                    !chunk.includes("npm WARN") &&
+                    !chunk.includes("ENOENT")) {
+                    errorOutput += chunk;
+                }
+                // Always send to callback for visibility
+                if (options?.errorCallback) {
+                    options.errorCallback(maskSensitiveOutput(chunk));
+                }
+            });
+            child.on("error", (error) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.runningProcesses.delete(processId);
+                resolve(failure(getErrorMessage(error)));
+            });
+            child.on("close", (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.runningProcesses.delete(processId);
+                if (processKilled) {
+                    resolve(failure("CDK command timed out"));
+                    return;
+                }
+                const exitedClean = code === 0 || (options?.ignoreExitCode === true && code === 1);
+                // For diff command, we need to include stderr in output since CDK outputs errors there
+                const combinedOutput = output + (errorOutput ? `\n${errorOutput}` : "");
+                if (exitedClean) {
+                    resolve(success({
+                        output: args.includes("diff") ? combinedOutput : output,
+                        exitCode: code || 0
+                    }));
+                    return;
+                }
+                // Parse error output for meaningful messages
+                let errorMessage = errorOutput;
+                if (output) {
+                    // Try to extract error from CDK output
+                    const errorMatch = output.match(/❌.*?Error:(.*)$/m);
+                    if (errorMatch) {
+                        errorMessage = errorMatch[1].trim();
+                    }
+                }
+                // Include stdout in the error string so callers can pattern-match on combined output
+                const errorText = errorMessage || `CDK command failed with exit code ${code}`;
+                const fullError = output ? `${errorText}\n${output}` : errorText;
+                resolve(failure(fullError));
+            });
+        });
+    }
+}

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

@@ -0,0 +1,71 @@
+import { type ResourceEvent } from "../../aws/utils/cloudformationEvents.js";
+import type { DeploymentContext } from "../../types/deployment/DeploymentTypes.js";
+import type { StepOutput } from "../../types/deployment/DeploymentTypes.js";
+import type { AwsProvider } from "../../aws/AwsProvider.js";
+import type { Result } from "@fjall/generator";
+import type { CdkError } from "../../types/errors/CdkError.js";
+import type { EventLogWriterFactory } from "../../aws/utils/cloudformationEvents.js";
+import { type CheckDifferencesResult } from "./CdkCommandRunner.js";
+export interface CdkContext {
+    accountId?: string;
+    region?: string;
+    environment?: string;
+    stackName?: string;
+    managedAccount?: boolean;
+    accountName?: string;
+    imageVersion?: string;
+    orgId?: string;
+    rootId?: string;
+    managementAccountId?: string;
+    ipamPoolId?: string;
+    fjallOrgId?: string;
+    orgConfig?: string;
+}
+export interface CdkOptions {
+    verbose?: boolean;
+    noPrompt?: boolean;
+    outputCallback?: (output: string) => void;
+    errorCallback?: (error: string) => void;
+    context?: CdkContext;
+    timeout?: number;
+    passThroughCDK?: boolean;
+    stacks?: string[];
+    noLookups?: boolean;
+    useCdkOut?: boolean;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    outputDir?: string;
+    appDir?: string;
+    cdkOutputLogger?: {
+        writeCdkOutput(stream: "stdout" | "stderr", chunk: string): void;
+    };
+}
+export interface CdkOutput {
+    output?: string;
+    exitCode?: number;
+}
+export interface CdkServiceOptions {
+    eventLogWriterFactory?: EventLogWriterFactory;
+}
+export { type CheckDifferencesResult } from "./CdkCommandRunner.js";
+export declare class CdkService {
+    private commandRunner;
+    private eventMonitor;
+    constructor(options?: CdkServiceOptions);
+    checkDifferences(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CheckDifferencesResult, CdkError>>;
+    deploy(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    destroy(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    runImport(path: string, resourceMappingFile?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    synth(path: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    bootstrap(accountId: string, region: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    private resolveStackName;
+    private buildDeploymentCdkContext;
+    runCdkSynth(context: DeploymentContext, onOutput?: (chunk: string) => void): Promise<Result<StepOutput, string>>;
+    runCdkBootstrap(context: DeploymentContext, onOutput?: (chunk: string) => void): Promise<Result<StepOutput, string>>;
+    runCdkDiff(context: DeploymentContext, onOutput?: (chunk: string) => void): Promise<Result<StepOutput, string>>;
+    runCdkDeploy(context: DeploymentContext, stackPattern?: string, onOutput?: (chunk: string) => void, onResourceProgress?: (event: ResourceEvent) => void, aws?: AwsProvider): Promise<Result<StepOutput, string>>;
+    runCdkDestroy(context: DeploymentContext, stackPattern?: string, onOutput?: (chunk: string) => void, onResourceProgress?: (event: ResourceEvent) => void, aws?: AwsProvider, useCdkOut?: boolean): Promise<Result<StepOutput, string>>;
+}

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

@@ -0,0 +1,254 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { logger } from "@fjall/util";
+import { success, failure } from "@fjall/generator";
+import { DEFAULT_REGION } from "../../aws/utils/regions.js";
+import { getApplicationStackName, getOrganisationStackName, isApplicationStack } from "../../types/operations.js";
+import { getErrorMessage } from "@fjall/util";
+import { CdkEventMonitor, startStackMonitoring } from "./CdkEventMonitoring.js";
+import { analyseDeployOutput, analyseDestroyResult, createEnhancedOutputCallback } from "./CdkOutputAnalyser.js";
+import { CdkCommandRunner } from "./CdkCommandRunner.js";
+/** Delay before falling back to the predicted stack name for CloudFormation monitoring */
+const STACK_DETECTION_FALLBACK_MS = 5_000;
+export class CdkService {
+    commandRunner;
+    eventMonitor;
+    constructor(options) {
+        this.commandRunner = new CdkCommandRunner();
+        this.eventMonitor = new CdkEventMonitor({
+            eventLogWriterFactory: options?.eventLogWriterFactory
+        });
+    }
+    // Delegate low-level commands to CdkCommandRunner
+    async checkDifferences(path, stackName, options) {
+        return this.commandRunner.checkDifferences(path, stackName, options);
+    }
+    async deploy(path, stackName, options) {
+        return this.commandRunner.deploy(path, stackName, options);
+    }
+    async destroy(path, stackName, options) {
+        return this.commandRunner.destroy(path, stackName, options);
+    }
+    async runImport(path, resourceMappingFile, options) {
+        return this.commandRunner.runImport(path, resourceMappingFile, options);
+    }
+    async synth(path, options) {
+        return this.commandRunner.synth(path, options);
+    }
+    async bootstrap(accountId, region, options) {
+        return this.commandRunner.bootstrap(accountId, region, options);
+    }
+    resolveStackName(stackPattern, context) {
+        if (stackPattern && !stackPattern.includes("*")) {
+            return stackPattern;
+        }
+        if (stackPattern) {
+            const stackTypeMatch = stackPattern.match(/\*?(\w+)\*?/);
+            if (stackTypeMatch) {
+                const stackType = stackTypeMatch[1];
+                const appName = context.target || "app";
+                return isApplicationStack(stackType)
+                    ? getApplicationStackName(appName, stackType)
+                    : `${appName}${stackType}`;
+            }
+            return stackPattern;
+        }
+        return undefined;
+    }
+    buildDeploymentCdkContext(context, accountId, region, options) {
+        const environment = undefined;
+        return {
+            accountId,
+            region,
+            environment,
+            managedAccount: context.isManagedAccount,
+            ...(options?.includeImageVersion !== false && {
+                imageVersion: context.imageVersion
+            }),
+            orgId: context.orgId,
+            rootId: context.rootId,
+            managementAccountId: context.managementAccountId,
+            ipamPoolId: context.ipamPoolId,
+            fjallOrgId: context.fjallOrgId,
+            orgConfig: context.orgConfig
+        };
+    }
+    async runCdkSynth(context, onOutput) {
+        const accountId = context.callerIdentity?.Account;
+        try {
+            const result = await this.synth(context.path, {
+                outputCallback: onOutput,
+                context: this.buildDeploymentCdkContext(context, accountId, context.region || DEFAULT_REGION)
+            });
+            if (!result.success) {
+                return failure(result.error || "Failed to synthesise CloudFormation template");
+            }
+            return success({
+                message: "CloudFormation template synthesised",
+                details: result.data.output
+                    ? { synthesisTime: result.data.output }
+                    : undefined
+            });
+        }
+        catch (error) {
+            return failure(`CDK synth failed: ${getErrorMessage(error)}`);
+        }
+    }
+    async runCdkBootstrap(context, onOutput) {
+        const accountId = context.callerIdentity?.Account;
+        const region = context.region || DEFAULT_REGION;
+        try {
+            if (!accountId) {
+                return failure("No AWS account ID available");
+            }
+            const nodeModulesPath = join(context.path, "node_modules");
+            if (!existsSync(nodeModulesPath)) {
+                return failure(`Dependencies not installed. Please run 'npm install' in ${context.path} before deploying.`);
+            }
+            const result = await this.bootstrap(accountId, region, {
+                outputCallback: onOutput
+            });
+            if (!result.success) {
+                return failure(result.error || "Failed to bootstrap AWS environment");
+            }
+            return success({ message: "AWS environment bootstrapped" });
+        }
+        catch (error) {
+            return failure(`CDK bootstrap failed: ${getErrorMessage(error)}`);
+        }
+    }
+    async runCdkDiff(context, onOutput) {
+        const accountId = context.callerIdentity?.Account;
+        try {
+            const result = await this.checkDifferences(context.path, undefined, {
+                verbose: context.options?.verbose,
+                outputCallback: onOutput,
+                context: this.buildDeploymentCdkContext(context, accountId, context.region || DEFAULT_REGION)
+            });
+            if (!result.success) {
+                return failure(`CDK diff failed: ${result.error.message}`);
+            }
+            return success({
+                message: "Diff check complete",
+                details: {
+                    hasDifferences: result.data.hasDifferences,
+                    details: result.data.details
+                }
+            });
+        }
+        catch (error) {
+            return failure(`CDK diff failed: ${getErrorMessage(error)}`);
+        }
+    }
+    async runCdkDeploy(context, stackPattern, onOutput, onResourceProgress, aws) {
+        const accountId = context.callerIdentity?.Account;
+        const region = context.region || DEFAULT_REGION;
+        if (!accountId) {
+            return failure("AWS account ID not available. Please ensure AWS credentials are properly configured.");
+        }
+        if (!aws) {
+            return failure("AwsProvider is required for deployment monitoring.");
+        }
+        let cfnMonitor = null;
+        let fallbackMonitoringTimeout;
+        try {
+            const targetStackName = this.resolveStackName(stackPattern, context) ??
+                (() => {
+                    const deployType = context.deployType;
+                    if (deployType === "organisation" ||
+                        deployType === "platform" ||
+                        deployType === "account") {
+                        return getOrganisationStackName(deployType);
+                    }
+                    const appName = context.target || "app";
+                    return `${appName}Network`;
+                })();
+            cfnMonitor = await this.eventMonitor.createEventMonitor("deploy", targetStackName, region, context, aws);
+            if (onOutput) {
+                onOutput(`Starting CloudFormation deployment of ${targetStackName}...\n`);
+                onOutput(`Monitoring CloudFormation events (CDK process running in background)...\n`);
+            }
+            const state = {
+                cdkOutput: "",
+                actualStackName: targetStackName,
+                stackDetected: false,
+                monitoringPromise: null
+            };
+            const enhancedOutputCallback = createEnhancedOutputCallback(state, onOutput, cfnMonitor, onResourceProgress);
+            // Fall back to predicted stack name if actual name not detected in time
+            fallbackMonitoringTimeout = setTimeout(() => {
+                if (!state.stackDetected && cfnMonitor && !state.monitoringPromise) {
+                    logger.debug("CdkService", "Fallback monitoring STARTING", {
+                        targetStackName,
+                        stackDetected: state.stackDetected,
+                        hasOnResourceProgress: !!onResourceProgress
+                    });
+                    state.monitoringPromise = startStackMonitoring(cfnMonitor, targetStackName, onResourceProgress);
+                }
+            }, STACK_DETECTION_FALLBACK_MS);
+            const result = await this.deploy(context.path, targetStackName, {
+                verbose: context.options?.verbose,
+                outputCallback: enhancedOutputCallback,
+                useCdkOut: true,
+                cdkOutputLogger: cfnMonitor?.getEventLogger() ?? undefined,
+                context: this.buildDeploymentCdkContext(context, accountId, region)
+            });
+            clearTimeout(fallbackMonitoringTimeout);
+            if (cfnMonitor) {
+                logger.debug("CdkService", "CDK process exited, stopping monitor", {
+                    targetStackName,
+                    stackDetected: state.stackDetected,
+                    hadMonitoringPromise: !!state.monitoringPromise
+                });
+                cfnMonitor.stopMonitoring();
+            }
+            return analyseDeployOutput(state.cdkOutput, result, state.actualStackName);
+        }
+        catch (error) {
+            clearTimeout(fallbackMonitoringTimeout);
+            if (cfnMonitor) {
+                cfnMonitor.stopMonitoring();
+            }
+            const errorMsg = `CDK deploy failed: ${getErrorMessage(error)}`;
+            logger.error("CdkService", "CDK deployment exception", {
+                error: errorMsg
+            });
+            return failure(errorMsg);
+        }
+    }
+    async runCdkDestroy(context, stackPattern, onOutput, onResourceProgress, aws, useCdkOut) {
+        const accountId = context.callerIdentity?.Account;
+        const region = context.region || DEFAULT_REGION;
+        let cfnMonitor = null;
+        try {
+            const targetStackName = this.resolveStackName(stackPattern, context);
+            if (accountId && targetStackName && aws) {
+                cfnMonitor = await this.eventMonitor.createEventMonitor("destroy", targetStackName, region, context, aws);
+                cfnMonitor.startMonitoring(targetStackName, (event) => {
+                    onResourceProgress?.(event);
+                }, (_success, _message) => {
+                    // Stack destroy completed — no console output per architecture
+                });
+            }
+            const result = await this.destroy(context.path, stackPattern, {
+                verbose: context.options?.verbose,
+                outputCallback: onOutput,
+                useCdkOut,
+                cdkOutputLogger: cfnMonitor?.getEventLogger() ?? undefined,
+                context: this.buildDeploymentCdkContext(context, accountId, region, {
+                    includeImageVersion: false
+                })
+            });
+            if (cfnMonitor) {
+                cfnMonitor.stopMonitoring();
+            }
+            return analyseDestroyResult(result);
+        }
+        catch (error) {
+            if (cfnMonitor) {
+                cfnMonitor.stopMonitoring();
+            }
+            return failure(`CDK destroy failed: ${getErrorMessage(error)}`);
+        }
+    }
+}