@fjall/deploy-core 0.94.1 → 0.95.0

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

@@ -1,213 +1,3 @@
-import { existsSync } from "fs";
-import { join } from "path";
-import { logger } from "@fjall/util/logger";
-import { success, failure } from "@fjall/generator";
-import { DEFAULT_REGION } from "../../aws/utils/regions.js";
-import { getErrorMessage, maskSensitiveOutput } from "@fjall/util";
-import { CdkEventMonitor, startStackMonitoring } from "./CdkEventMonitoring.js";
-import { analyseDeployOutput, analyseDestroyResult, createEnhancedOutputCallback } from "./CdkOutputAnalyser.js";
-import { CdkCommandRunner } from "./CdkCommandRunner.js";
-import { CdkArgumentBuilder } from "./CdkArgumentBuilder.js";
-import { CdkProcessManager } from "./CdkProcessManager.js";
-import { wrapWithConstructMapEnrichment } from "./constructMapEnrichment.js";
-import { STACK_DETECTION_FALLBACK_MS, resolveStackName, getFallbackStackName, buildDeploymentCdkContext } from "./cdkServiceHelpers.js";
-export class CdkService {
-    commandRunner;
-    eventMonitor;
-    constructor(options) {
-        const processManager = options?.processManager ??
-            new CdkProcessManager(new CdkArgumentBuilder());
-        this.commandRunner = new CdkCommandRunner(processManager);
-        this.eventMonitor = new CdkEventMonitor({
-            eventLogWriterFactory: options?.eventLogWriterFactory
-        });
-    }
-    dispose() {
-        this.commandRunner.dispose();
-    }
-    // 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);
-    }
-    async runCdkSynth(context, onOutput) {
-        const accountId = context.callerIdentity?.Account;
-        try {
-            const result = await this.synth(context.path, {
-                outputCallback: onOutput,
-                context: 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, credentials) {
-        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,
-                credentials
-            });
-            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: 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, credentials) {
-        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.");
-        }
-        // Read construct map from fjall-manifest.json (written during synth)
-        const enrichedOnResourceProgress = wrapWithConstructMapEnrichment(context.path, onResourceProgress);
-        let cfnMonitor = null;
-        let fallbackMonitoringTimeout;
-        try {
-            const targetStackName = resolveStackName(stackPattern, context) ??
-                getFallbackStackName(context);
-            cfnMonitor = await this.eventMonitor.createEventMonitor("deploy", targetStackName, region, context, aws);
-            if (onOutput) {
-                onOutput(maskSensitiveOutput(`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, enrichedOnResourceProgress);
-            // 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, enrichedOnResourceProgress);
-                }
-            }, 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: buildDeploymentCdkContext(context, accountId, region),
-                credentials
-            });
-            return analyseDeployOutput(state.cdkOutput, result, state.actualStackName);
-        }
-        catch (error) {
-            const errorMsg = `CDK deploy failed: ${getErrorMessage(error)}`;
-            logger.error("CdkService", "CDK deployment exception", {
-                error: errorMsg
-            });
-            return failure(errorMsg);
-        }
-        finally {
-            clearTimeout(fallbackMonitoringTimeout);
-            if (cfnMonitor) {
-                cfnMonitor.stopMonitoring();
-            }
-        }
-    }
-    async runCdkDestroy(context, stackPattern, onOutput, onResourceProgress, aws, useCdkOut, credentials) {
-        const accountId = context.callerIdentity?.Account;
-        const region = context.region || DEFAULT_REGION;
-        let cfnMonitor = null;
-        try {
-            const targetStackName = 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: buildDeploymentCdkContext(context, accountId, region, {
-                    includeImageVersion: false
-                }),
-                credentials
-            });
-            return analyseDestroyResult(result);
-        }
-        catch (error) {
-            return failure(`CDK destroy failed: ${getErrorMessage(error)}`);
-        }
-        finally {
-            if (cfnMonitor) {
-                cfnMonitor.stopMonitoring();
-            }
-        }
-    }
-}
+import{existsSync as v}from"fs";import{join as M}from"path";import{logger as C}from"@fjall/util/logger";import{success as h,failure as s}from"@fjall/generator";import{DEFAULT_REGION as f}from"../../aws/utils/regions.js";import{getErrorMessage as g,maskSensitiveOutput as S}from"@fjall/util";import{CdkEventMonitor as I,startStackMonitoring as A}from"./CdkEventMonitoring.js";import{analyseDeployOutput as R,analyseDestroyResult as E,createEnhancedOutputCallback as F}from"./CdkOutputAnalyser.js";import{CdkCommandRunner as w}from"./CdkCommandRunner.js";import{CdkArgumentBuilder as K}from"./CdkArgumentBuilder.js";import{CdkProcessManager as N}from"./CdkProcessManager.js";import{wrapWithConstructMapEnrichment as O}from"./constructMapEnrichment.js";import{STACK_DETECTION_FALLBACK_MS as T,resolveStackName as D,getFallbackStackName as L,buildDeploymentCdkContext as y}from"./cdkServiceHelpers.js";class X{commandRunner;eventMonitor;constructor(e){const t=e?.processManager??new N(new K);this.commandRunner=new w(t),this.eventMonitor=new I({eventLogWriterFactory:e?.eventLogWriterFactory})}dispose(){this.commandRunner.dispose()}async checkDifferences(e,t,r){return this.commandRunner.checkDifferences(e,t,r)}async deploy(e,t,r){return this.commandRunner.deploy(e,t,r)}async destroy(e,t,r){return this.commandRunner.destroy(e,t,r)}async runImport(e,t,r){return this.commandRunner.runImport(e,t,r)}async synth(e,t){return this.commandRunner.synth(e,t)}async bootstrap(e,t,r){return this.commandRunner.bootstrap(e,t,r)}async runCdkSynth(e,t){const r=e.callerIdentity?.Account;try{const n=await this.synth(e.path,{outputCallback:t,context:y(e,r,e.region||f)});return n.success?h({message:"CloudFormation template synthesised",details:n.data.output?{synthesisTime:n.data.output}:void 0}):s(n.error||"Failed to synthesise CloudFormation template")}catch(n){return s(`CDK synth failed: ${g(n)}`)}}async runCdkBootstrap(e,t,r){const n=e.callerIdentity?.Account,u=e.region||f;try{if(!n)return s("No AWS account ID available");const d=M(e.path,"node_modules");if(!v(d))return s(`Dependencies not installed. Please run 'npm install' in ${e.path} before deploying.`);const l=await this.bootstrap(n,u,{outputCallback:t,credentials:r});return l.success?h({message:"AWS environment bootstrapped"}):s(l.error||"Failed to bootstrap AWS environment")}catch(d){return s(`CDK bootstrap failed: ${g(d)}`)}}async runCdkDiff(e,t){const r=e.callerIdentity?.Account;try{const n=await this.checkDifferences(e.path,void 0,{verbose:e.options?.verbose,outputCallback:t,context:y(e,r,e.region||f)});return n.success?h({message:"Diff check complete",details:{hasDifferences:n.data.hasDifferences,details:n.data.details}}):s(`CDK diff failed: ${n.error.message}`)}catch(n){return s(`CDK diff failed: ${g(n)}`)}}async runCdkDeploy(e,t,r,n,u,d){const l=e.callerIdentity?.Account,m=e.region||f;if(!l)return s("AWS account ID not available. Please ensure AWS credentials are properly configured.");if(!u)return s("AwsProvider is required for deployment monitoring.");const p=O(e.path,n);let o=null,c;try{const i=D(t,e)??L(e);o=await this.eventMonitor.createEventMonitor("deploy",i,m,e,u),r&&(r(S(`Starting CloudFormation deployment of ${i}...
+`)),r(`Monitoring CloudFormation events (CDK process running in background)...
+`));const a={cdkOutput:"",actualStackName:i,stackDetected:!1,monitoringPromise:null},k=F(a,r,o,p);c=setTimeout(()=>{!a.stackDetected&&o&&!a.monitoringPromise&&(C.debug("CdkService","Fallback monitoring STARTING",{targetStackName:i,stackDetected:a.stackDetected,hasOnResourceProgress:!!n}),a.monitoringPromise=A(o,i,p))},T);const b=await this.deploy(e.path,i,{verbose:e.options?.verbose,outputCallback:k,useCdkOut:!0,cdkOutputLogger:o?.getEventLogger()??void 0,context:y(e,l,m),credentials:d});return R(a.cdkOutput,b,a.actualStackName)}catch(i){const a=`CDK deploy failed: ${g(i)}`;return C.error("CdkService","CDK deployment exception",{error:a}),s(a)}finally{clearTimeout(c),o&&o.stopMonitoring()}}async runCdkDestroy(e,t,r,n,u,d,l){const m=e.callerIdentity?.Account,p=e.region||f;let o=null;try{const c=D(t,e);m&&c&&u&&(o=await this.eventMonitor.createEventMonitor("destroy",c,p,e,u),o.startMonitoring(c,a=>{n?.(a)},(a,k)=>{}));const i=await this.destroy(e.path,t,{verbose:e.options?.verbose,outputCallback:r,useCdkOut:d,cdkOutputLogger:o?.getEventLogger()??void 0,context:y(e,m,p,{includeImageVersion:!1}),credentials:l});return E(i)}catch(c){return s(`CDK destroy failed: ${g(c)}`)}finally{o&&o.stopMonitoring()}}}export{X as CdkService};

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

@@ -1,248 +1 @@
-import { CloudFormationClient, DeleteStackCommand, DescribeStacksCommand, ListExportsCommand } from "@aws-sdk/client-cloudformation";
-import { stackStatusMap } from "../../aws/utils/stackStatus.js";
-import { success, failure } from "@fjall/generator";
-import { BaseServiceError } from "../../types/errors/ServiceError.js";
-import { logger } from "@fjall/util/logger";
-import { getErrorMessage, sleep } from "@fjall/util";
-import { STACK_NOT_FOUND_PATTERN } from "@fjall/util/aws";
-import { extractErrorName } from "../../aws/organisations/types.js";
-/**
- * CloudFormation-specific error
- */
-export class CloudFormationError extends BaseServiceError {
-    errorType;
-    stackName;
-    stackStatus;
-    constructor(message, errorType, stackName, stackStatus, details, recoverable = false) {
-        super(`CFN_${errorType.toUpperCase()}`, message, details, recoverable);
-        this.errorType = errorType;
-        this.stackName = stackName;
-        this.stackStatus = stackStatus;
-    }
-}
-/**
- * CloudFormation service using the AwsProvider interface.
- *
- * Unlike the CLI version which lazily initialises AwsContext,
- * deploy-core receives a pre-configured AwsProvider at construction.
- */
-export class CloudFormationService {
-    aws;
-    constructor(aws) {
-        this.aws = aws;
-    }
-    /**
-     * Classify an AWS SDK error into a typed CloudFormationError.
-     */
-    classifyAwsError(error, fallbackMessage, stackName) {
-        const errorName = extractErrorName(error);
-        const errorMessage = getErrorMessage(error);
-        if (errorName === "CredentialsError" || errorName === "UnauthorizedError") {
-            return new CloudFormationError(`AWS credentials error: ${errorMessage}`, "auth_error", stackName, undefined, error, false);
-        }
-        if (errorName === "Throttling" ||
-            errorName === "TooManyRequestsException") {
-            return new CloudFormationError(`AWS rate limit exceeded: ${errorMessage}`, "throttled", stackName, undefined, error, true);
-        }
-        if (errorName === "NetworkingError" || errorName === "ENOTFOUND") {
-            return new CloudFormationError(`Network error: ${errorMessage}`, "network_error", stackName, undefined, error, true);
-        }
-        return new CloudFormationError(`${fallbackMessage}: ${errorMessage}`, "unknown", stackName, undefined, error);
-    }
-    /**
-     * Get stack outputs for services that need them
-     */
-    async getStackOutputs(stackName, callbacks) {
-        callbacks?.onStackCheck?.(stackName);
-        const client = this.aws.getClient(CloudFormationClient);
-        const command = new DescribeStacksCommand({ StackName: stackName });
-        try {
-            const response = await client.send(command);
-            const stack = response.Stacks?.[0];
-            if (!stack?.Outputs) {
-                return success([]);
-            }
-            const outputs = stack.Outputs.map((output) => ({
-                OutputKey: output.OutputKey,
-                OutputValue: output.OutputValue,
-                ExportName: output.ExportName
-            }));
-            callbacks?.onOutputsRetrieved?.(stackName, outputs.length);
-            return success(outputs);
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                error.name === "ValidationError" &&
-                error.message?.includes(STACK_NOT_FOUND_PATTERN)) {
-                callbacks?.onStackNotFound?.(stackName);
-                return success([]);
-            }
-            return failure(new CloudFormationError(`Failed to get outputs for stack ${stackName}: ${getErrorMessage(error)}`, "unknown", stackName, undefined, error));
-        }
-    }
-    /**
-     * Get stack status directly
-     */
-    async getStackStatus(stackName, callbacks) {
-        callbacks?.onStackCheck?.(stackName);
-        const client = this.aws.getClient(CloudFormationClient);
-        const command = new DescribeStacksCommand({ StackName: stackName });
-        try {
-            const response = await client.send(command);
-            const stack = response.Stacks?.[0];
-            if (!stack) {
-                return success({
-                    status: "DOES_NOT_EXIST",
-                    safeToRedeploy: "Yes",
-                    description: "Stack does not exist yet"
-                });
-            }
-            const status = stack.StackStatus || "UNKNOWN";
-            const statusInfo = stackStatusMap[status] || stackStatusMap["UNKNOWN"];
-            callbacks?.onStackFound?.(stackName, status);
-            return success({
-                status,
-                safeToRedeploy: statusInfo.safeToRedeploy,
-                description: statusInfo.description,
-                statusReason: stack.StackStatusReason
-            });
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                error.name === "ValidationError" &&
-                error.message?.includes(STACK_NOT_FOUND_PATTERN)) {
-                return success({
-                    status: "DOES_NOT_EXIST",
-                    safeToRedeploy: "Yes",
-                    description: "Stack does not exist yet"
-                });
-            }
-            return failure(this.classifyAwsError(error, `Failed to get stack status for ${stackName}`, stackName));
-        }
-    }
-    /**
-     * Internal helper to list all CloudFormation exports with pagination.
-     */
-    async listAllExports(earlyExit) {
-        const client = this.aws.getClient(CloudFormationClient);
-        const allExports = [];
-        try {
-            let nextToken;
-            do {
-                const command = new ListExportsCommand({ NextToken: nextToken });
-                const response = await client.send(command);
-                const pageExports = response.Exports || [];
-                for (const exp of pageExports) {
-                    if (exp.Name && exp.Value) {
-                        allExports.push({ Name: exp.Name, Value: exp.Value });
-                    }
-                }
-                if (earlyExit?.(pageExports)) {
-                    break;
-                }
-                nextToken = response.NextToken;
-            } while (nextToken);
-            return success(allExports);
-        }
-        catch (error) {
-            return failure(new CloudFormationError(`Failed to list exports: ${getErrorMessage(error)}`, "unknown", undefined, undefined, error, false));
-        }
-    }
-    /**
-     * Look up specific CloudFormation exports by exact name.
-     */
-    async getExportsByNames(names) {
-        if (names.length === 0) {
-            return success(new Map());
-        }
-        const nameSet = new Set(names);
-        const found = new Map();
-        const result = await this.listAllExports((pageExports) => {
-            for (const exp of pageExports) {
-                if (exp.Name && nameSet.has(exp.Name) && exp.Value) {
-                    found.set(exp.Name, exp.Value);
-                }
-            }
-            return found.size >= nameSet.size;
-        });
-        if (!result.success) {
-            return failure(result.error);
-        }
-        return success(found);
-    }
-    /**
-     * List all CloudFormation exports
-     */
-    async listExports(callbacks) {
-        const result = await this.listAllExports();
-        if (result.success) {
-            callbacks?.onExportsRetrieved?.(result.data.length);
-        }
-        return result;
-    }
-    /**
-     * Delete a CloudFormation stack directly via the API.
-     * Unlike CDK destroy, this works on stacks in DELETE_FAILED state.
-     */
-    async deleteStack(stackName) {
-        const client = this.aws.getClient(CloudFormationClient);
-        try {
-            await client.send(new DeleteStackCommand({ StackName: stackName }));
-            return success(undefined);
-        }
-        catch (error) {
-            return failure(this.classifyAwsError(error, `Failed to delete stack ${stackName}`, stackName));
-        }
-    }
-    /**
-     * Check whether a CloudFormation stack exists and is in a deployable state.
-     */
-    async stackExists(stackName, client) {
-        const cfnClient = client ?? this.aws.getClient(CloudFormationClient);
-        try {
-            const response = await cfnClient.send(new DescribeStacksCommand({ StackName: stackName }));
-            const status = response.Stacks?.[0]?.StackStatus;
-            return !!status && status !== "REVIEW_IN_PROGRESS";
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                error.message?.includes(STACK_NOT_FOUND_PATTERN)) {
-                return false;
-            }
-            logger.debug("CloudFormationService", "Error checking stack existence, assuming exists", {
-                stackName,
-                error: getErrorMessage(error)
-            });
-            return true;
-        }
-    }
-    /**
-     * Poll stack status until deletion completes, fails, or times out.
-     */
-    async waitForDeleteComplete(stackName, options) {
-        const timeoutMs = options?.timeoutMs ?? 10 * 60 * 1000;
-        const pollIntervalMs = options?.pollIntervalMs ?? 5000;
-        const start = Date.now();
-        while (Date.now() - start < timeoutMs) {
-            const statusResult = await this.getStackStatus(stackName);
-            if (!statusResult.success) {
-                if (statusResult.error.recoverable) {
-                    options?.onProgress?.(`Transient error polling stack ${stackName}, retrying: ${statusResult.error.message}`);
-                    await sleep(pollIntervalMs);
-                    continue;
-                }
-                return failure(statusResult.error);
-            }
-            const status = statusResult.data?.status;
-            if (status === "DELETE_COMPLETE" || status === "DOES_NOT_EXIST") {
-                return success(undefined);
-            }
-            if (status === "DELETE_FAILED") {
-                return failure(new CloudFormationError(`Stack ${stackName} deletion failed: ${statusResult.data?.statusReason || "unknown reason"}`, "stack_failed", stackName, status, undefined, false));
-            }
-            options?.onProgress?.(`Stack ${stackName} status: ${status ?? "unknown"}`);
-            await sleep(pollIntervalMs);
-        }
-        return failure(new CloudFormationError(`Timed out waiting for stack ${stackName} deletion after ${Math.round(timeoutMs / 1000)}s`, "timeout", stackName, undefined, undefined, true));
-    }
-}
+import{CloudFormationClient as d,DeleteStackCommand as g,DescribeStacksCommand as p,ListExportsCommand as h}from"@aws-sdk/client-cloudformation";import{stackStatusMap as E}from"../../aws/utils/stackStatus.js";import{success as u,failure as c}from"@fjall/generator";import{BaseServiceError as k}from"../../types/errors/ServiceError.js";import{logger as x}from"@fjall/util/logger";import{getErrorMessage as f,sleep as S}from"@fjall/util";import{STACK_NOT_FOUND_PATTERN as w}from"@fjall/util/aws";import{extractErrorName as y}from"../../aws/organisations/types.js";class l extends k{errorType;stackName;stackStatus;constructor(t,r,n,e,s,o=!1){super(`CFN_${r.toUpperCase()}`,t,s,o),this.errorType=r,this.stackName=n,this.stackStatus=e}}class D{aws;constructor(t){this.aws=t}classifyAwsError(t,r,n){const e=y(t),s=f(t);return e==="CredentialsError"||e==="UnauthorizedError"?new l(`AWS credentials error: ${s}`,"auth_error",n,void 0,t,!1):e==="Throttling"||e==="TooManyRequestsException"?new l(`AWS rate limit exceeded: ${s}`,"throttled",n,void 0,t,!0):e==="NetworkingError"||e==="ENOTFOUND"?new l(`Network error: ${s}`,"network_error",n,void 0,t,!0):new l(`${r}: ${s}`,"unknown",n,void 0,t)}async getStackOutputs(t,r){r?.onStackCheck?.(t);const n=this.aws.getClient(d),e=new p({StackName:t});try{const o=(await n.send(e)).Stacks?.[0];if(!o?.Outputs)return u([]);const a=o.Outputs.map(i=>({OutputKey:i.OutputKey,OutputValue:i.OutputValue,ExportName:i.ExportName}));return r?.onOutputsRetrieved?.(t,a.length),u(a)}catch(s){return s instanceof Error&&s.name==="ValidationError"&&s.message?.includes(w)?(r?.onStackNotFound?.(t),u([])):c(new l(`Failed to get outputs for stack ${t}: ${f(s)}`,"unknown",t,void 0,s))}}async getStackStatus(t,r){r?.onStackCheck?.(t);const n=this.aws.getClient(d),e=new p({StackName:t});try{const o=(await n.send(e)).Stacks?.[0];if(!o)return u({status:"DOES_NOT_EXIST",safeToRedeploy:"Yes",description:"Stack does not exist yet"});const a=o.StackStatus||"UNKNOWN",i=E[a]||E.UNKNOWN;return r?.onStackFound?.(t,a),u({status:a,safeToRedeploy:i.safeToRedeploy,description:i.description,statusReason:o.StackStatusReason})}catch(s){return s instanceof Error&&s.name==="ValidationError"&&s.message?.includes(w)?u({status:"DOES_NOT_EXIST",safeToRedeploy:"Yes",description:"Stack does not exist yet"}):c(this.classifyAwsError(s,`Failed to get stack status for ${t}`,t))}}async listAllExports(t){const r=this.aws.getClient(d),n=[];try{let e;do{const s=new h({NextToken:e}),o=await r.send(s),a=o.Exports||[];for(const i of a)i.Name&&i.Value&&n.push({Name:i.Name,Value:i.Value});if(t?.(a))break;e=o.NextToken}while(e);return u(n)}catch(e){return c(new l(`Failed to list exports: ${f(e)}`,"unknown",void 0,void 0,e,!1))}}async getExportsByNames(t){if(t.length===0)return u(new Map);const r=new Set(t),n=new Map,e=await this.listAllExports(s=>{for(const o of s)o.Name&&r.has(o.Name)&&o.Value&&n.set(o.Name,o.Value);return n.size>=r.size});return e.success?u(n):c(e.error)}async listExports(t){const r=await this.listAllExports();return r.success&&t?.onExportsRetrieved?.(r.data.length),r}async deleteStack(t){const r=this.aws.getClient(d);try{return await r.send(new g({StackName:t})),u(void 0)}catch(n){return c(this.classifyAwsError(n,`Failed to delete stack ${t}`,t))}}async stackExists(t,r){const n=r??this.aws.getClient(d);try{const s=(await n.send(new p({StackName:t}))).Stacks?.[0]?.StackStatus;return!!s&&s!=="REVIEW_IN_PROGRESS"}catch(e){return e instanceof Error&&e.message?.includes(w)?!1:(x.debug("CloudFormationService","Error checking stack existence, assuming exists",{stackName:t,error:f(e)}),!0)}}async waitForDeleteComplete(t,r){const n=r?.timeoutMs??6e5,e=r?.pollIntervalMs??5e3,s=Date.now();for(;Date.now()-s<n;){const o=await this.getStackStatus(t);if(!o.success){if(o.error.recoverable){r?.onProgress?.(`Transient error polling stack ${t}, retrying: ${o.error.message}`),await S(e);continue}return c(o.error)}const a=o.data?.status;if(a==="DELETE_COMPLETE"||a==="DOES_NOT_EXIST")return u(void 0);if(a==="DELETE_FAILED")return c(new l(`Stack ${t} deletion failed: ${o.data?.statusReason||"unknown reason"}`,"stack_failed",t,a,void 0,!1));r?.onProgress?.(`Stack ${t} status: ${a??"unknown"}`),await S(e)}return c(new l(`Timed out waiting for stack ${t} deletion after ${Math.round(n/1e3)}s`,"timeout",t,void 0,void 0,!0))}}export{l as CloudFormationError,D as CloudFormationService};

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

@@ -1 +0,0 @@
-export {};

package/dist/src/services/supporting/CdkContextBuilder.js

@@ -1,44 +1 @@
-import { DEFAULT_REGION } from "@fjall/generator";
-/**
- * Builder for creating standardised CDK deployment contexts.
- * Ensures all required fields are present with proper defaults.
- *
- * Unlike the CLI version, this uses OrgConfig (injected) rather than
- * Config.loadConfig() (file-based) for region resolution.
- */
-export class CdkContextBuilder {
-    /**
-     * Build a standardised deployment context for CDK operations.
-     * Ensures all required fields are present with proper defaults.
-     */
-    static buildDeploymentContext(input, options, orgConfig) {
-        return {
-            deployType: input.deployType,
-            target: input.target,
-            path: input.path,
-            options: options,
-            stackOutputs: input.stackOutputs || {},
-            callerIdentity: input.callerIdentity,
-            region: input.region || orgConfig?.primaryRegion || DEFAULT_REGION,
-            isManagedAccount: input.isManagedAccount,
-            accountName: input.accountName,
-            logPath: input.logPath,
-            imageVersion: input.imageVersion,
-            orgId: input.orgId,
-            rootId: input.rootId,
-            managementAccountId: input.managementAccountId,
-            ipamPoolId: input.ipamPoolId,
-            fjallOrgId: input.fjallOrgId,
-            orgConfig: input.orgConfig
-        };
-    }
-    /**
-     * Build context from an existing context with updated options
-     */
-    static updateContext(existingContext, updates) {
-        return {
-            ...existingContext,
-            ...updates
-        };
-    }
-}
+import{DEFAULT_REGION as t}from"@fjall/generator";class d{static buildDeploymentContext(o,e,a){return{deployType:o.deployType,target:o.target,path:o.path,options:e,stackOutputs:o.stackOutputs||{},callerIdentity:o.callerIdentity,region:o.region||a?.primaryRegion||t,isManagedAccount:o.isManagedAccount,accountName:o.accountName,logPath:o.logPath,imageVersion:o.imageVersion,orgId:o.orgId,rootId:o.rootId,managementAccountId:o.managementAccountId,ipamPoolId:o.ipamPoolId,fjallOrgId:o.fjallOrgId,orgConfig:o.orgConfig}}static updateContext(o,e){return{...o,...e}}}export{d as CdkContextBuilder};