@aws-cdk/toolkit-lib 1.24.0 → 1.25.0

package/lib/api/stack-events/resource-errors.d.ts

@@ -0,0 +1,82 @@
+import type { StackEvent } from '@aws-sdk/client-cloudformation';
+import type { ResourceEvent } from './stack-event-poller';
+export interface ResourceError {
+    /**
+     * The stack this resource error occurred in
+     *
+     * NOTE: This will be a stack ID (which is a full ARN including the unique identifier),
+     * not just a name.
+     */
+    readonly stackArn: string;
+    /**
+     * IDs of parent stacks of the resource, in case of resources in nested stacks
+     */
+    readonly parentStackLogicalIds: string[];
+    /**
+     * Logical ID of the resource
+     *
+     * (May be absent in case this message is about the stack itself)
+     */
+    readonly logicalId?: string;
+    /**
+     * Resource type
+     */
+    readonly resourceType?: string;
+    /**
+     * Physical ID of the resource
+     */
+    readonly physicalId?: string;
+    /**
+     * Error message of the resource
+     */
+    readonly message: string;
+    /**
+     * Error code of the resource
+     */
+    readonly errorCode?: string;
+}
+/**
+ * Class used to send stack event errors into, to come up with root causes.
+ */
+export declare class ResourceErrors {
+    /**
+     * A list of all non-cancellation errors we have seen.
+     *
+     * By the nature of the order we see events in, will be ordered from oldest to newest.
+     */
+    private readonly _errors;
+    isEmpty(): boolean;
+    get all(): ReadonlyArray<ResourceError>;
+    /**
+     * Update the error collection with the given stack activity
+     *
+     * May be from a nested stack as well.
+     *
+     * This class expects to see all events in chronological order.
+     */
+    update(...events: ResourceEvent[]): void;
+    /**
+     * Take our best guess at the error code of the root cause
+     *
+     * The first error that occurs is the root cause.
+     */
+    get rootCauseErrorCode(): string | undefined;
+    /**
+     * Return error messages of all encountered errors (that aren't cancellations)
+     */
+    get allErrorMessages(): string[];
+    /**
+     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
+     *
+     * We don't need to include nested stack errors because our poller will poll the nested stack,
+     * and have returned the actual error as well.
+     */
+    get allErrorCodes(): string[];
+}
+/**
+ * Extract an error code from the given stack event.
+ *
+ * Always contains the services, and includes the handler error code if available.
+ */
+export declare function extractErrorCode(event: StackEvent): string;
+//# sourceMappingURL=resource-errors.d.ts.map

package/lib/api/stack-events/resource-errors.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceErrors = void 0;
+exports.extractErrorCode = extractErrorCode;
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const cloudformation_1 = require("../../util/cloudformation");
+/**
+ * Class used to send stack event errors into, to come up with root causes.
+ */
+class ResourceErrors {
+    /**
+     * A list of all non-cancellation errors we have seen.
+     *
+     * By the nature of the order we see events in, will be ordered from oldest to newest.
+     */
+    _errors = [];
+    isEmpty() {
+        return this._errors.length === 0;
+    }
+    get all() {
+        return this._errors;
+    }
+    /**
+     * Update the error collection with the given stack activity
+     *
+     * May be from a nested stack as well.
+     *
+     * This class expects to see all events in chronological order.
+     */
+    update(...events) {
+        for (const event of events) {
+            if ((0, cloudformation_1.isErrorEvent)(event.event)) {
+                // Cancelled is not an interesting failure reason, nor is the stack message (stack
+                // message will just say something like "stack failed to update")
+                if (!(0, cloudformation_1.isCancellationEvent)(event.event) && (0, cloudformation_1.isRegularResourceEvent)(event.event)) {
+                    this._errors.push(errorFromEvent(event));
+                }
+            }
+        }
+    }
+    /**
+     * Take our best guess at the error code of the root cause
+     *
+     * The first error that occurs is the root cause.
+     */
+    get rootCauseErrorCode() {
+        return this.allErrorCodes[0];
+    }
+    /**
+     * Return error messages of all encountered errors (that aren't cancellations)
+     */
+    get allErrorMessages() {
+        return this._errors.map(e => e.message);
+    }
+    /**
+     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
+     *
+     * We don't need to include nested stack errors because our poller will poll the nested stack,
+     * and have returned the actual error as well.
+     */
+    get allErrorCodes() {
+        return this._errors.map(e => e.errorCode).filter(x => typeof x === 'string');
+    }
+}
+exports.ResourceErrors = ResourceErrors;
+function errorFromEvent(ev) {
+    // FIXME: Check hooks
+    return {
+        logicalId: ev.event.LogicalResourceId ?? '',
+        message: ev.event.ResourceStatusReason ?? '',
+        parentStackLogicalIds: ev.parentStackLogicalIds,
+        resourceType: ev.event.ResourceType ?? '',
+        stackArn: ev.event.StackId ?? '',
+        errorCode: extractErrorCode(ev.event),
+        physicalId: ev.event.PhysicalResourceId,
+    };
+}
+/**
+ * Extract an error code from the given stack event.
+ *
+ * Always contains the services, and includes the handler error code if available.
+ */
+function extractErrorCode(event) {
+    const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');
+    // Get the resource type; if it is non-AWS then we are done.
+    const resourceTypeParts = (event.ResourceType ?? '').split('::');
+    if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {
+        return toolkit_error_1.DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;
+    }
+    const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');
+    const reason = event.ResourceStatusReason ?? '';
+    const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;
+    const handlerCode = reason.match(errorRe);
+    return `${resourceType}:${handlerCode ? handlerCode[1] : toolkit_error_1.DeploymentErrorCodes.UNKNOWN_ERROR}`;
+}
+// Some custom resource types that the CDK standard library creates that we
+// would like to see it if they fail.
+const OUR_CUSTOM_RESOURCE_TYPES = [
+    'Custom::AWS',
+    'Custom::AWSCDK-EKS-Cluster',
+    'Custom::AWSCDK-EKS-FargateProfile',
+    'Custom::AWSCDK-EKS-HelmChart',
+    'Custom::AWSCDK-EKS-KubernetesObjectValue',
+    'Custom::AWSCDK-EKS-KubernetesPatch',
+    'Custom::AWSCDK-EKS-KubernetesResource',
+    'Custom::AWSCDKCfnJson',
+    'Custom::AWSCDKCfnJsonStringify',
+    'Custom::AWSCDKOpenIdConnectProvider',
+    'Custom::CDKBucketDeployment',
+    'Custom::CloudwatchLogResourcePolicy',
+    'Custom::CrossAccountZoneDelegation',
+    'Custom::CrossRegionExportReader',
+    'Custom::CrossRegionExportWriter',
+    'Custom::CrossRegionStringParameterReader',
+    'Custom::DeleteExistingRecordSet',
+    'Custom::DescribeCognitoUserPoolClient',
+    'Custom::DynamoDBReplica',
+    'Custom::ECRAutoDeleteImages',
+    'Custom::ElasticsearchAccessPolicy',
+    'Custom::LogRetention',
+    'Custom::OpenSearchAccessPolicy',
+    'Custom::S3AutoDeleteObjects',
+    'Custom::S3BucketNotifications',
+    'Custom::SyntheticsAutoDeleteUnderlyingResources',
+    'Custom::Trigger',
+    'Custom::UserPoolCloudFrontDomainName',
+    'Custom::VpcRestrictDefaultSG',
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-errors.js","sourceRoot":"","sources":["resource-errors.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport type { ResourceEvent } from './stack-event-poller';\nimport { DeploymentErrorCodes } from '../../toolkit/toolkit-error';\nimport { isCancellationEvent, isErrorEvent, isRegularResourceEvent } from '../../util/cloudformation';\n\nexport interface ResourceError {\n  /**\n   * The stack this resource error occurred in\n   *\n   * NOTE: This will be a stack ID (which is a full ARN including the unique identifier),\n   * not just a name.\n   */\n  readonly stackArn: string;\n\n  /**\n   * IDs of parent stacks of the resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Logical ID of the resource\n   *\n   * (May be absent in case this message is about the stack itself)\n   */\n  readonly logicalId?: string;\n\n  /**\n   * Resource type\n   */\n  readonly resourceType?: string;\n\n  /**\n   * Physical ID of the resource\n   */\n  readonly physicalId?: string;\n\n  /**\n   * Error message of the resource\n   */\n  readonly message: string;\n\n  /**\n   * Error code of the resource\n   */\n  readonly errorCode?: string;\n}\n\n/**\n * Class used to send stack event errors into, to come up with root causes.\n */\nexport class ResourceErrors {\n  /**\n   * A list of all non-cancellation errors we have seen.\n   *\n   * By the nature of the order we see events in, will be ordered from oldest to newest.\n   */\n  private readonly _errors: ResourceError[] = [];\n\n  public isEmpty() {\n    return this._errors.length === 0;\n  }\n\n  public get all(): ReadonlyArray<ResourceError> {\n    return this._errors;\n  }\n\n  /**\n   * Update the error collection with the given stack activity\n   *\n   * May be from a nested stack as well.\n   *\n   * This class expects to see all events in chronological order.\n   */\n  public update(...events: ResourceEvent[]) {\n    for (const event of events) {\n      if (isErrorEvent(event.event)) {\n        // Cancelled is not an interesting failure reason, nor is the stack message (stack\n        // message will just say something like \"stack failed to update\")\n        if (!isCancellationEvent(event.event) && isRegularResourceEvent(event.event)) {\n          this._errors.push(errorFromEvent(event));\n        }\n      }\n    }\n  }\n\n  /**\n   * Take our best guess at the error code of the root cause\n   *\n   * The first error that occurs is the root cause.\n   */\n  public get rootCauseErrorCode(): string | undefined {\n    return this.allErrorCodes[0];\n  }\n\n  /**\n   * Return error messages of all encountered errors (that aren't cancellations)\n   */\n  public get allErrorMessages(): string[] {\n    return this._errors.map(e => e.message);\n  }\n\n  /**\n   * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)\n   *\n   * We don't need to include nested stack errors because our poller will poll the nested stack,\n   * and have returned the actual error as well.\n   */\n  public get allErrorCodes(): string[] {\n    return this._errors.map(e => e.errorCode).filter(x => typeof x === 'string');\n  }\n}\n\nfunction errorFromEvent(ev: ResourceEvent): ResourceError {\n  // FIXME: Check hooks\n\n  return {\n    logicalId: ev.event.LogicalResourceId ?? '',\n    message: ev.event.ResourceStatusReason ?? '',\n    parentStackLogicalIds: ev.parentStackLogicalIds,\n    resourceType: ev.event.ResourceType ?? '',\n    stackArn: ev.event.StackId ?? '',\n    errorCode: extractErrorCode(ev.event),\n    physicalId: ev.event.PhysicalResourceId,\n  };\n}\n\n/**\n * Extract an error code from the given stack event.\n *\n * Always contains the services, and includes the handler error code if available.\n */\nexport function extractErrorCode(event: StackEvent): string {\n  const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');\n\n  // Get the resource type; if it is non-AWS then we are done.\n  const resourceTypeParts = (event.ResourceType ?? '').split('::');\n  if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {\n    return DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;\n  }\n\n  const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');\n\n  const reason = event.ResourceStatusReason ?? '';\n\n  const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;\n  const handlerCode = reason.match(errorRe);\n\n  return `${resourceType}:${handlerCode ? handlerCode[1] : DeploymentErrorCodes.UNKNOWN_ERROR}`;\n}\n\n// Some custom resource types that the CDK standard library creates that we\n// would like to see it if they fail.\nconst OUR_CUSTOM_RESOURCE_TYPES = [\n  'Custom::AWS',\n  'Custom::AWSCDK-EKS-Cluster',\n  'Custom::AWSCDK-EKS-FargateProfile',\n  'Custom::AWSCDK-EKS-HelmChart',\n  'Custom::AWSCDK-EKS-KubernetesObjectValue',\n  'Custom::AWSCDK-EKS-KubernetesPatch',\n  'Custom::AWSCDK-EKS-KubernetesResource',\n  'Custom::AWSCDKCfnJson',\n  'Custom::AWSCDKCfnJsonStringify',\n  'Custom::AWSCDKOpenIdConnectProvider',\n  'Custom::CDKBucketDeployment',\n  'Custom::CloudwatchLogResourcePolicy',\n  'Custom::CrossAccountZoneDelegation',\n  'Custom::CrossRegionExportReader',\n  'Custom::CrossRegionExportWriter',\n  'Custom::CrossRegionStringParameterReader',\n  'Custom::DeleteExistingRecordSet',\n  'Custom::DescribeCognitoUserPoolClient',\n  'Custom::DynamoDBReplica',\n  'Custom::ECRAutoDeleteImages',\n  'Custom::ElasticsearchAccessPolicy',\n  'Custom::LogRetention',\n  'Custom::OpenSearchAccessPolicy',\n  'Custom::S3AutoDeleteObjects',\n  'Custom::S3BucketNotifications',\n  'Custom::SyntheticsAutoDeleteUnderlyingResources',\n  'Custom::Trigger',\n  'Custom::UserPoolCloudFrontDomainName',\n  'Custom::VpcRestrictDefaultSG',\n];\n"]}

package/lib/api/stack-events/stack-activity-monitor.d.ts

@@ -1,5 +1,4 @@
 import type { CloudFormationStackArtifact } from '@aws-cdk/cloud-assembly-api';
-import type { StackEvent } from '@aws-sdk/client-cloudformation';
 import type { ICloudFormationClient } from '../aws-auth/private';
 import type { EnvironmentResources } from '../environment';
 import { type IoHelper } from '../io/private';
@@ -76,12 +75,6 @@ export declare class StackActivityMonitor {
      * Printers can decide to update a view less frequently if desired
      */
     private readonly pollingInterval;
-    /**
-     * A list of all non-cancellation errors we have seen.
-     *
-     * By the nature of the order we see events in, will be ordered from oldest to newest.
-     */
-    private readonly _errors;
     private monitorId?;
     private readonly progressMonitor;
     /**
@@ -99,22 +92,9 @@ export declare class StackActivityMonitor {
     private readonly envResources?;
     constructor({ cfn, ioHelper, stack, stackName, resourcesTotal, changeSetCreationTime, pollingInterval, envResources, }: StackActivityMonitorProps);
     /**
-     * Return error messages of all encountered errors (that aren't cancellations)
-     */
-    get allErrorMessages(): string[];
-    /**
-     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
-     *
-     * We don't need to include nested stack errors because our poller will poll the nested stack,
-     * and have returned the actual error as well.
-     */
-    get allErrorCodes(): string[];
-    /**
-     * Take our best guess at the error code of the root cause
-     *
-     * The first error that occurs is the root cause.
+     * The resource errors that were discovered during monitoring of this stack
      */
-    get rootCauseErrorCode(): string | undefined;
+    get errors(): import("./resource-errors").ResourceErrors;
     start(): Promise<this>;
     stop(): Promise<void>;
     private scheduleNextTick;
@@ -149,12 +129,5 @@ export declare class StackActivityMonitor {
      * Formats a stack activity into a basic string
      */
     private formatActivity;
-    private checkForErrors;
 }
-/**
- * Extract an error code from the given stack event.
- *
- * Always contains the services, and includes the handler error code if available.
- */
-export declare function extractErrorCode(event: StackEvent): string;
 //# sourceMappingURL=stack-activity-monitor.d.ts.map

package/lib/api/stack-events/stack-activity-monitor.js

@@ -1,13 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StackActivityMonitor = void 0;
-exports.extractErrorCode = extractErrorCode;
 const util = require("util");
 const uuid = require("uuid");
 const stack_event_poller_1 = require("./stack-event-poller");
 const stack_progress_monitor_1 = require("./stack-progress-monitor");
-const toolkit_error_1 = require("../../toolkit/toolkit-error");
-const util_1 = require("../../util");
 const private_1 = require("../io/private");
 const resource_metadata_1 = require("../resource-metadata/resource-metadata");
 /**
@@ -30,12 +27,6 @@ class StackActivityMonitor {
      * Printers can decide to update a view less frequently if desired
      */
     pollingInterval;
-    /**
-     * A list of all non-cancellation errors we have seen.
-     *
-     * By the nature of the order we see events in, will be ordered from oldest to newest.
-     */
-    _errors = [];
     monitorId;
     progressMonitor;
     /**
@@ -61,33 +52,14 @@ class StackActivityMonitor {
         this.pollingInterval = pollingInterval;
         this.poller = new stack_event_poller_1.StackEventPoller(cfn, {
             stackName,
-            startTime: changeSetCreationTime?.getTime() ?? Date.now(),
+            initialPollRange: stack_event_poller_1.PollRange.sinceTimestamp(changeSetCreationTime?.getTime() ?? Date.now()),
         });
     }
     /**
-     * Return error messages of all encountered errors (that aren't cancellations)
-     */
-    get allErrorMessages() {
-        return this._errors.map(e => e.ResourceStatusReason ?? '');
-    }
-    /**
-     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
-     *
-     * We don't need to include nested stack errors because our poller will poll the nested stack,
-     * and have returned the actual error as well.
+     * The resource errors that were discovered during monitoring of this stack
      */
-    get allErrorCodes() {
-        return this._errors
-            .filter(util_1.isRegularResourceEvent)
-            .map(extractErrorCode);
-    }
-    /**
-     * Take our best guess at the error code of the root cause
-     *
-     * The first error that occurs is the root cause.
-     */
-    get rootCauseErrorCode() {
-        return this.allErrorCodes[0];
+    get errors() {
+        return this.poller.errors;
     }
     async start() {
         this.monitorId = uuid.v4();
@@ -230,7 +202,6 @@ class StackActivityMonitor {
                 metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),
                 progress: this.progressMonitor.progress,
             };
-            this.checkForErrors(activity);
             await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5502.msg(this.formatActivity(activity, true), activity));
         }
     }
@@ -260,66 +231,6 @@ class StackActivityMonitor {
         const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : '';
         return util.format('%s | %s%s | %s | %s | %s %s%s%s', event.StackName, progress !== false ? `${activity.progress.formatted} | ` : '', new Date(event.Timestamp).toLocaleTimeString(), event.ResourceStatus || '', event.ResourceType, resourceName, logicalId, event.ResourceStatusReason ? event.ResourceStatusReason : '', metadata?.entry.trace ? `\n\t${metadata.entry.trace.join('\n\t\\_ ')}` : '');
     }
-    checkForErrors(activity) {
-        if ((0, util_1.isErrorEvent)(activity.event)) {
-            // Cancelled is not an interesting failure reason, nor is the stack message (stack
-            // message will just say something like "stack failed to update")
-            if (!(0, util_1.isCancellationEvent)(activity.event) && (0, util_1.isRegularResourceEvent)(activity.event)) {
-                this._errors.push(activity.event);
-            }
-        }
-    }
 }
 exports.StackActivityMonitor = StackActivityMonitor;
-// Some custom resource types that the CDK standard library creates that we
-// would like to see it if they fail.
-const OUR_CUSTOM_RESOURCE_TYPES = [
-    'Custom::AWS',
-    'Custom::AWSCDK-EKS-Cluster',
-    'Custom::AWSCDK-EKS-FargateProfile',
-    'Custom::AWSCDK-EKS-HelmChart',
-    'Custom::AWSCDK-EKS-KubernetesObjectValue',
-    'Custom::AWSCDK-EKS-KubernetesPatch',
-    'Custom::AWSCDK-EKS-KubernetesResource',
-    'Custom::AWSCDKCfnJson',
-    'Custom::AWSCDKCfnJsonStringify',
-    'Custom::AWSCDKOpenIdConnectProvider',
-    'Custom::CDKBucketDeployment',
-    'Custom::CloudwatchLogResourcePolicy',
-    'Custom::CrossAccountZoneDelegation',
-    'Custom::CrossRegionExportReader',
-    'Custom::CrossRegionExportWriter',
-    'Custom::CrossRegionStringParameterReader',
-    'Custom::DeleteExistingRecordSet',
-    'Custom::DescribeCognitoUserPoolClient',
-    'Custom::DynamoDBReplica',
-    'Custom::ECRAutoDeleteImages',
-    'Custom::ElasticsearchAccessPolicy',
-    'Custom::LogRetention',
-    'Custom::OpenSearchAccessPolicy',
-    'Custom::S3AutoDeleteObjects',
-    'Custom::S3BucketNotifications',
-    'Custom::SyntheticsAutoDeleteUnderlyingResources',
-    'Custom::Trigger',
-    'Custom::UserPoolCloudFrontDomainName',
-    'Custom::VpcRestrictDefaultSG',
-];
-/**
- * Extract an error code from the given stack event.
- *
- * Always contains the services, and includes the handler error code if available.
- */
-function extractErrorCode(event) {
-    const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');
-    // Get the resource type; if it is non-AWS then we are done.
-    const resourceTypeParts = (event.ResourceType ?? '').split('::');
-    if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {
-        return toolkit_error_1.DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;
-    }
-    const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');
-    const reason = event.ResourceStatusReason ?? '';
-    const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;
-    const handlerCode = reason.match(errorRe);
-    return `${resourceType}:${handlerCode ? handlerCode[1] : toolkit_error_1.DeploymentErrorCodes.UNKNOWN_ERROR}`;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-activity-monitor.js","sourceRoot":"","sources":["stack-activity-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport type { CloudFormationStackArtifact } from '@aws-cdk/cloud-assembly-api';\nimport type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport * as uuid from 'uuid';\nimport { StackEventPoller } from './stack-event-poller';\nimport { StackProgressMonitor } from './stack-progress-monitor';\nimport type { StackActivity } from '../../payloads/stack-activity';\nimport { DeploymentErrorCodes } from '../../toolkit/toolkit-error';\nimport { isCancellationEvent, isErrorEvent, isRegularResourceEvent } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\nimport type { EnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport { resourceMetadata } from '../resource-metadata/resource-metadata';\n\nexport interface StackActivityMonitorProps {\n  /**\n   * The CloudFormation client\n   */\n  readonly cfn: ICloudFormationClient;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The stack artifact that is getting deployed\n   */\n  readonly stack: CloudFormationStackArtifact;\n\n  /**\n   * The name of the Stack that is getting deployed\n   */\n  readonly stackName: string;\n\n  /**\n   * Total number of resources to update\n   *\n   * Used to calculate a progress bar.\n   *\n   * @default - No progress reporting\n   */\n  readonly resourcesTotal?: number;\n\n  /**\n   * Creation time of the change set\n   *\n   * This will be used to filter events, only showing those from after the change\n   * set creation time.\n   *\n   * It is recommended to use this, otherwise the filtering will be subject\n   * to clock drift between local and cloud machines.\n   *\n   * @default - Local machine's current time\n   */\n  readonly changeSetCreationTime?: Date;\n\n  /**\n   * Time to wait between fetching new activities.\n   *\n   * Must wait a reasonable amount of time between polls, since we need to consider CloudFormation API limits\n   *\n   * @default 2_000\n   */\n  readonly pollingInterval?: number;\n\n  /**\n   * Environment resources, used to look up the bootstrap toolkit version when\n   * diagnosing Guard Hook annotation fetch failures.\n   *\n   * @default - Bootstrap version is not reported in error messages\n   */\n  readonly envResources?: EnvironmentResources;\n}\n\n/**\n * Drives the monitoring of a Stack deployment\n *\n * ```\n * ┌───────────────────────┐        ┌───────────────────────┐              ┌───────────────────────┐\n * │         Stack         │ poll() │         Stack         │  process(ev) │         Stack         │\n * │      EventPoller      │◀───────│    ActivityMonitor    │─────────────▶│    ProgressMonitor    │\n * └───────────────────────┘        └───────────────────────┘              └───────────────────────┘\n * ```\n */\nexport class StackActivityMonitor {\n  /**\n   * The poller used to read stack events\n   */\n  private readonly poller: StackEventPoller;\n\n  /**\n   * Fetch new activity every 1 second\n   * Printers can decide to update a view less frequently if desired\n   */\n  private readonly pollingInterval: number;\n\n  /**\n   * A list of all non-cancellation errors we have seen.\n   *\n   * By the nature of the order we see events in, will be ordered from oldest to newest.\n   */\n  private readonly _errors: StackEvent[] = [];\n\n  private monitorId?: string;\n\n  private readonly progressMonitor: StackProgressMonitor;\n\n  /**\n   * Current tick timer\n   */\n  private tickTimer?: ReturnType<typeof setTimeout>;\n\n  /**\n   * Set to the activity of reading the current events\n   */\n  private readPromise?: Promise<any>;\n\n  private readonly ioHelper: IoHelper;\n  private readonly stackName: string;\n  private readonly stack: CloudFormationStackArtifact;\n  private readonly cfn: ICloudFormationClient;\n  private readonly envResources?: EnvironmentResources;\n\n  constructor({\n    cfn,\n    ioHelper,\n    stack,\n    stackName,\n    resourcesTotal,\n    changeSetCreationTime,\n    pollingInterval = 2_000,\n    envResources,\n  }: StackActivityMonitorProps) {\n    this.ioHelper = ioHelper;\n    this.stack = stack;\n    this.stackName = stackName;\n    this.cfn = cfn;\n    this.envResources = envResources;\n\n    this.progressMonitor = new StackProgressMonitor(resourcesTotal);\n    this.pollingInterval = pollingInterval;\n    this.poller = new StackEventPoller(cfn, {\n      stackName,\n      startTime: changeSetCreationTime?.getTime() ?? Date.now(),\n    });\n  }\n\n  /**\n   * Return error messages of all encountered errors (that aren't cancellations)\n   */\n  public get allErrorMessages(): string[] {\n    return this._errors.map(e => e.ResourceStatusReason ?? '');\n  }\n\n  /**\n   * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)\n   *\n   * We don't need to include nested stack errors because our poller will poll the nested stack,\n   * and have returned the actual error as well.\n   */\n  public get allErrorCodes(): string[] {\n    return this._errors\n      .filter(isRegularResourceEvent)\n      .map(extractErrorCode);\n  }\n\n  /**\n   * Take our best guess at the error code of the root cause\n   *\n   * The first error that occurs is the root cause.\n   */\n  public get rootCauseErrorCode(): string | undefined {\n    return this.allErrorCodes[0];\n  }\n\n  public async start() {\n    this.monitorId = uuid.v4();\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5501.msg(`Deploying ${this.stackName}`, {\n      deployment: this.monitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n    this.scheduleNextTick();\n    return this;\n  }\n\n  public async stop() {\n    const oldMonitorId = this.monitorId!;\n    this.monitorId = undefined;\n    if (this.tickTimer) {\n      clearTimeout(this.tickTimer);\n    }\n\n    // Do a final poll for all events. This is to handle the situation where DescribeStackStatus\n    // already returned an error, but the monitor hasn't seen all the events yet and we'd end\n    // up not printing the failure reason to users.\n    await this.finalPollToEnd(oldMonitorId);\n\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5503.msg(`Completed ${this.stackName}`, {\n      deployment: oldMonitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n  }\n\n  private scheduleNextTick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);\n  }\n\n  private async tick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    try {\n      this.readPromise = this.readNewEvents(this.monitorId);\n      await this.readPromise;\n      this.readPromise = undefined;\n\n      // We might have been stop()ped while the network call was in progress.\n      if (!this.monitorId) {\n        return;\n      }\n    } catch (e) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5500.msg(\n        util.format('Error occurred while monitoring stack: %s', e),\n        { error: e as any },\n      ));\n    }\n    this.scheduleNextTick();\n  }\n\n  private findMetadataFor(logicalId: string | undefined) {\n    const metadata = this.stack.metadata;\n    if (!logicalId || !metadata) {\n      return undefined;\n    }\n    return resourceMetadata(this.stack, logicalId);\n  }\n\n  /**\n   * Trims leading/trailing whitespace, collapses all internal whitespace\n   * (including newlines) to a single space, and truncates to `maxChars`\n   * characters, appending `[...truncated]` when the original was longer.\n   */\n  private normalizeMessage(message: string, maxChars: number = 400): string {\n    const normalized = message.trim().replace(/\\s+/g, ' ');\n    return normalized.length > maxChars\n      ? normalized.substring(0, maxChars) + '[...truncated]'\n      : normalized;\n  }\n\n  /**\n   * Fetches Guard Hook annotation details via GetHookResult API and formats them\n   * into a human-readable string. Returns undefined if the fetch fails or there\n   * are no failed annotations.\n   */\n  private async fetchGuardHookAnnotations(hookInvocationId: string): Promise<string | undefined> {\n    try {\n      const result = await this.cfn.getHookResult({ HookResultId: hookInvocationId });\n      const annotations = result.Annotations ?? [];\n      const failedAnnotations = annotations.filter((a) => a.Status === 'FAILED');\n      if (failedAnnotations.length === 0) {\n        return undefined;\n      }\n\n      const lines: string[] = ['NonCompliant Rules:', ''];\n      for (const annotation of failedAnnotations) {\n        if (annotation.AnnotationName) {\n          lines.push(`[${annotation.AnnotationName}]`);\n        }\n        if (annotation.StatusMessage) {\n          lines.push(`• ${this.normalizeMessage(annotation.StatusMessage)}`);\n        }\n        if (annotation.RemediationMessage) {\n          lines.push(`Remediation: ${this.normalizeMessage(annotation.RemediationMessage)}`);\n        }\n        lines.push('');\n      }\n      return lines.join('\\n').trimEnd();\n    } catch (e: any) {\n      const errorMessage = e instanceof Error ? e.message : String(e);\n\n      const isPermissionsError =\n        e.name === 'AccessDeniedException' ||\n        (typeof errorMessage === 'string' && errorMessage.toLowerCase().includes('not authorized to perform: cloudformation:gethookresult'));\n\n      if (isPermissionsError && this.envResources) {\n        let currentVersion: number | undefined = undefined;\n        try {\n          currentVersion = (await this.envResources.lookupToolkit()).version;\n        } catch {\n          // ignore errors looking up the bootstrap version\n        }\n\n        await this.ioHelper.defaults.warn(\n          util.format(\n            `Failed to fetch result details for Hook invocation ${hookInvocationId}: ${errorMessage}. Make sure you have permissions to call the GetHookResult API, or re-bootstrap your environment by running 'cdk bootstrap' to update the Bootstrap CDK Toolkit stack.\n            'Bootstrap toolkit stack version 31 or later is needed; current version: ${currentVersion ?? 'unknown'}.`,\n          ),\n        );\n      } else {\n        await this.ioHelper.defaults.warn(\n          util.format('Failed to fetch Guard Hook details for invocation %s: %s', hookInvocationId, errorMessage),\n        );\n      }\n\n      return undefined;\n    }\n  }\n\n  /**\n   * Reads all new events from the stack history\n   *\n   * The events are returned in chronological order by the underlying poller.\n   */\n  private async readNewEvents(monitorId: string): Promise<void> {\n    const pollEvents = await this.poller.poll();\n\n    for (const resourceEvent of pollEvents) {\n      this.progressMonitor.process(resourceEvent.event);\n\n      // If this is a failed Guard Hook event with an invocation ID, fetch annotations\n      if (resourceEvent.event.HookInvocationId) {\n        const annotations = await this.fetchGuardHookAnnotations(resourceEvent.event.HookInvocationId);\n        if (annotations) {\n          resourceEvent.event.HookStatusReason = annotations;\n        }\n      }\n\n      const activity: StackActivity = {\n        deployment: monitorId,\n        event: resourceEvent.event,\n        metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),\n        progress: this.progressMonitor.progress,\n      };\n\n      this.checkForErrors(activity);\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I5502.msg(this.formatActivity(activity, true), activity));\n    }\n  }\n\n  /**\n   * Perform a final poll to the end and flush out all events to the printer\n   *\n   * Finish any poll currently in progress, then do a final one until we've\n   * reached the last page.\n   */\n  private async finalPollToEnd(monitorId: string) {\n    // If we were doing a poll, finish that first. It was started before\n    // the moment we were sure we weren't going to get any new events anymore\n    // so we need to do a new one anyway. Need to wait for this one though\n    // because our state is single-threaded.\n    if (this.readPromise) {\n      await this.readPromise;\n    }\n\n    await this.readNewEvents(monitorId);\n  }\n\n  /**\n   * Formats a stack activity into a basic string\n   */\n  private formatActivity(activity: StackActivity, progress: boolean): string {\n    const event = activity.event;\n    const metadata = activity.metadata;\n\n    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || '';\n    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : '';\n\n    return util.format(\n      '%s | %s%s | %s | %s | %s %s%s%s',\n      event.StackName,\n      progress !== false ? `${activity.progress.formatted} | ` : '',\n      new Date(event.Timestamp!).toLocaleTimeString(),\n      event.ResourceStatus || '',\n      event.ResourceType,\n      resourceName,\n      logicalId,\n      event.ResourceStatusReason ? event.ResourceStatusReason : '',\n      metadata?.entry.trace ? `\\n\\t${metadata.entry.trace.join('\\n\\t\\\\_ ')}` : '',\n    );\n  }\n\n  private checkForErrors(activity: StackActivity) {\n    if (isErrorEvent(activity.event)) {\n      // Cancelled is not an interesting failure reason, nor is the stack message (stack\n      // message will just say something like \"stack failed to update\")\n      if (!isCancellationEvent(activity.event) && isRegularResourceEvent(activity.event)) {\n        this._errors.push(activity.event);\n      }\n    }\n  }\n}\n\n// Some custom resource types that the CDK standard library creates that we\n// would like to see it if they fail.\nconst OUR_CUSTOM_RESOURCE_TYPES = [\n  'Custom::AWS',\n  'Custom::AWSCDK-EKS-Cluster',\n  'Custom::AWSCDK-EKS-FargateProfile',\n  'Custom::AWSCDK-EKS-HelmChart',\n  'Custom::AWSCDK-EKS-KubernetesObjectValue',\n  'Custom::AWSCDK-EKS-KubernetesPatch',\n  'Custom::AWSCDK-EKS-KubernetesResource',\n  'Custom::AWSCDKCfnJson',\n  'Custom::AWSCDKCfnJsonStringify',\n  'Custom::AWSCDKOpenIdConnectProvider',\n  'Custom::CDKBucketDeployment',\n  'Custom::CloudwatchLogResourcePolicy',\n  'Custom::CrossAccountZoneDelegation',\n  'Custom::CrossRegionExportReader',\n  'Custom::CrossRegionExportWriter',\n  'Custom::CrossRegionStringParameterReader',\n  'Custom::DeleteExistingRecordSet',\n  'Custom::DescribeCognitoUserPoolClient',\n  'Custom::DynamoDBReplica',\n  'Custom::ECRAutoDeleteImages',\n  'Custom::ElasticsearchAccessPolicy',\n  'Custom::LogRetention',\n  'Custom::OpenSearchAccessPolicy',\n  'Custom::S3AutoDeleteObjects',\n  'Custom::S3BucketNotifications',\n  'Custom::SyntheticsAutoDeleteUnderlyingResources',\n  'Custom::Trigger',\n  'Custom::UserPoolCloudFrontDomainName',\n  'Custom::VpcRestrictDefaultSG',\n];\n\n/**\n * Extract an error code from the given stack event.\n *\n * Always contains the services, and includes the handler error code if available.\n */\nexport function extractErrorCode(event: StackEvent): string {\n  const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');\n\n  // Get the resource type; if it is non-AWS then we are done.\n  const resourceTypeParts = (event.ResourceType ?? '').split('::');\n  if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {\n    return DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;\n  }\n\n  const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');\n\n  const reason = event.ResourceStatusReason ?? '';\n\n  const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;\n  const handlerCode = reason.match(errorRe);\n\n  return `${resourceType}:${handlerCode ? handlerCode[1] : DeploymentErrorCodes.UNKNOWN_ERROR}`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-activity-monitor.js","sourceRoot":"","sources":["stack-activity-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport type { CloudFormationStackArtifact } from '@aws-cdk/cloud-assembly-api';\nimport * as uuid from 'uuid';\nimport { StackEventPoller, PollRange } from './stack-event-poller';\nimport { StackProgressMonitor } from './stack-progress-monitor';\nimport type { StackActivity } from '../../payloads/stack-activity';\nimport type { ICloudFormationClient } from '../aws-auth/private';\nimport type { EnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport { resourceMetadata } from '../resource-metadata/resource-metadata';\n\nexport interface StackActivityMonitorProps {\n  /**\n   * The CloudFormation client\n   */\n  readonly cfn: ICloudFormationClient;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The stack artifact that is getting deployed\n   */\n  readonly stack: CloudFormationStackArtifact;\n\n  /**\n   * The name of the Stack that is getting deployed\n   */\n  readonly stackName: string;\n\n  /**\n   * Total number of resources to update\n   *\n   * Used to calculate a progress bar.\n   *\n   * @default - No progress reporting\n   */\n  readonly resourcesTotal?: number;\n\n  /**\n   * Creation time of the change set\n   *\n   * This will be used to filter events, only showing those from after the change\n   * set creation time.\n   *\n   * It is recommended to use this, otherwise the filtering will be subject\n   * to clock drift between local and cloud machines.\n   *\n   * @default - Local machine's current time\n   */\n  readonly changeSetCreationTime?: Date;\n\n  /**\n   * Time to wait between fetching new activities.\n   *\n   * Must wait a reasonable amount of time between polls, since we need to consider CloudFormation API limits\n   *\n   * @default 2_000\n   */\n  readonly pollingInterval?: number;\n\n  /**\n   * Environment resources, used to look up the bootstrap toolkit version when\n   * diagnosing Guard Hook annotation fetch failures.\n   *\n   * @default - Bootstrap version is not reported in error messages\n   */\n  readonly envResources?: EnvironmentResources;\n}\n\n/**\n * Drives the monitoring of a Stack deployment\n *\n * ```\n * ┌───────────────────────┐        ┌───────────────────────┐              ┌───────────────────────┐\n * │         Stack         │ poll() │         Stack         │  process(ev) │         Stack         │\n * │      EventPoller      │◀───────│    ActivityMonitor    │─────────────▶│    ProgressMonitor    │\n * └───────────────────────┘        └───────────────────────┘              └───────────────────────┘\n * ```\n */\nexport class StackActivityMonitor {\n  /**\n   * The poller used to read stack events\n   */\n  private readonly poller: StackEventPoller;\n\n  /**\n   * Fetch new activity every 1 second\n   * Printers can decide to update a view less frequently if desired\n   */\n  private readonly pollingInterval: number;\n\n  private monitorId?: string;\n\n  private readonly progressMonitor: StackProgressMonitor;\n\n  /**\n   * Current tick timer\n   */\n  private tickTimer?: ReturnType<typeof setTimeout>;\n\n  /**\n   * Set to the activity of reading the current events\n   */\n  private readPromise?: Promise<any>;\n\n  private readonly ioHelper: IoHelper;\n  private readonly stackName: string;\n  private readonly stack: CloudFormationStackArtifact;\n  private readonly cfn: ICloudFormationClient;\n  private readonly envResources?: EnvironmentResources;\n\n  constructor({\n    cfn,\n    ioHelper,\n    stack,\n    stackName,\n    resourcesTotal,\n    changeSetCreationTime,\n    pollingInterval = 2_000,\n    envResources,\n  }: StackActivityMonitorProps) {\n    this.ioHelper = ioHelper;\n    this.stack = stack;\n    this.stackName = stackName;\n    this.cfn = cfn;\n    this.envResources = envResources;\n\n    this.progressMonitor = new StackProgressMonitor(resourcesTotal);\n    this.pollingInterval = pollingInterval;\n    this.poller = new StackEventPoller(cfn, {\n      stackName,\n      initialPollRange: PollRange.sinceTimestamp(changeSetCreationTime?.getTime() ?? Date.now()),\n    });\n  }\n\n  /**\n   * The resource errors that were discovered during monitoring of this stack\n   */\n  public get errors() {\n    return this.poller.errors;\n  }\n\n  public async start() {\n    this.monitorId = uuid.v4();\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5501.msg(`Deploying ${this.stackName}`, {\n      deployment: this.monitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n    this.scheduleNextTick();\n    return this;\n  }\n\n  public async stop() {\n    const oldMonitorId = this.monitorId!;\n    this.monitorId = undefined;\n    if (this.tickTimer) {\n      clearTimeout(this.tickTimer);\n    }\n\n    // Do a final poll for all events. This is to handle the situation where DescribeStackStatus\n    // already returned an error, but the monitor hasn't seen all the events yet and we'd end\n    // up not printing the failure reason to users.\n    await this.finalPollToEnd(oldMonitorId);\n\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5503.msg(`Completed ${this.stackName}`, {\n      deployment: oldMonitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n  }\n\n  private scheduleNextTick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);\n  }\n\n  private async tick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    try {\n      this.readPromise = this.readNewEvents(this.monitorId);\n      await this.readPromise;\n      this.readPromise = undefined;\n\n      // We might have been stop()ped while the network call was in progress.\n      if (!this.monitorId) {\n        return;\n      }\n    } catch (e) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5500.msg(\n        util.format('Error occurred while monitoring stack: %s', e),\n        { error: e as any },\n      ));\n    }\n    this.scheduleNextTick();\n  }\n\n  private findMetadataFor(logicalId: string | undefined) {\n    const metadata = this.stack.metadata;\n    if (!logicalId || !metadata) {\n      return undefined;\n    }\n    return resourceMetadata(this.stack, logicalId);\n  }\n\n  /**\n   * Trims leading/trailing whitespace, collapses all internal whitespace\n   * (including newlines) to a single space, and truncates to `maxChars`\n   * characters, appending `[...truncated]` when the original was longer.\n   */\n  private normalizeMessage(message: string, maxChars: number = 400): string {\n    const normalized = message.trim().replace(/\\s+/g, ' ');\n    return normalized.length > maxChars\n      ? normalized.substring(0, maxChars) + '[...truncated]'\n      : normalized;\n  }\n\n  /**\n   * Fetches Guard Hook annotation details via GetHookResult API and formats them\n   * into a human-readable string. Returns undefined if the fetch fails or there\n   * are no failed annotations.\n   */\n  private async fetchGuardHookAnnotations(hookInvocationId: string): Promise<string | undefined> {\n    try {\n      const result = await this.cfn.getHookResult({ HookResultId: hookInvocationId });\n      const annotations = result.Annotations ?? [];\n      const failedAnnotations = annotations.filter((a) => a.Status === 'FAILED');\n      if (failedAnnotations.length === 0) {\n        return undefined;\n      }\n\n      const lines: string[] = ['NonCompliant Rules:', ''];\n      for (const annotation of failedAnnotations) {\n        if (annotation.AnnotationName) {\n          lines.push(`[${annotation.AnnotationName}]`);\n        }\n        if (annotation.StatusMessage) {\n          lines.push(`• ${this.normalizeMessage(annotation.StatusMessage)}`);\n        }\n        if (annotation.RemediationMessage) {\n          lines.push(`Remediation: ${this.normalizeMessage(annotation.RemediationMessage)}`);\n        }\n        lines.push('');\n      }\n      return lines.join('\\n').trimEnd();\n    } catch (e: any) {\n      const errorMessage = e instanceof Error ? e.message : String(e);\n\n      const isPermissionsError =\n        e.name === 'AccessDeniedException' ||\n        (typeof errorMessage === 'string' && errorMessage.toLowerCase().includes('not authorized to perform: cloudformation:gethookresult'));\n\n      if (isPermissionsError && this.envResources) {\n        let currentVersion: number | undefined = undefined;\n        try {\n          currentVersion = (await this.envResources.lookupToolkit()).version;\n        } catch {\n          // ignore errors looking up the bootstrap version\n        }\n\n        await this.ioHelper.defaults.warn(\n          util.format(\n            `Failed to fetch result details for Hook invocation ${hookInvocationId}: ${errorMessage}. Make sure you have permissions to call the GetHookResult API, or re-bootstrap your environment by running 'cdk bootstrap' to update the Bootstrap CDK Toolkit stack.\n            'Bootstrap toolkit stack version 31 or later is needed; current version: ${currentVersion ?? 'unknown'}.`,\n          ),\n        );\n      } else {\n        await this.ioHelper.defaults.warn(\n          util.format('Failed to fetch Guard Hook details for invocation %s: %s', hookInvocationId, errorMessage),\n        );\n      }\n\n      return undefined;\n    }\n  }\n\n  /**\n   * Reads all new events from the stack history\n   *\n   * The events are returned in chronological order by the underlying poller.\n   */\n  private async readNewEvents(monitorId: string): Promise<void> {\n    const pollEvents = await this.poller.poll();\n\n    for (const resourceEvent of pollEvents) {\n      this.progressMonitor.process(resourceEvent.event);\n\n      // If this is a failed Guard Hook event with an invocation ID, fetch annotations\n      if (resourceEvent.event.HookInvocationId) {\n        const annotations = await this.fetchGuardHookAnnotations(resourceEvent.event.HookInvocationId);\n        if (annotations) {\n          resourceEvent.event.HookStatusReason = annotations;\n        }\n      }\n\n      const activity: StackActivity = {\n        deployment: monitorId,\n        event: resourceEvent.event,\n        metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),\n        progress: this.progressMonitor.progress,\n      };\n\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I5502.msg(this.formatActivity(activity, true), activity));\n    }\n  }\n\n  /**\n   * Perform a final poll to the end and flush out all events to the printer\n   *\n   * Finish any poll currently in progress, then do a final one until we've\n   * reached the last page.\n   */\n  private async finalPollToEnd(monitorId: string) {\n    // If we were doing a poll, finish that first. It was started before\n    // the moment we were sure we weren't going to get any new events anymore\n    // so we need to do a new one anyway. Need to wait for this one though\n    // because our state is single-threaded.\n    if (this.readPromise) {\n      await this.readPromise;\n    }\n\n    await this.readNewEvents(monitorId);\n  }\n\n  /**\n   * Formats a stack activity into a basic string\n   */\n  private formatActivity(activity: StackActivity, progress: boolean): string {\n    const event = activity.event;\n    const metadata = activity.metadata;\n\n    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || '';\n    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : '';\n\n    return util.format(\n      '%s | %s%s | %s | %s | %s %s%s%s',\n      event.StackName,\n      progress !== false ? `${activity.progress.formatted} | ` : '',\n      new Date(event.Timestamp!).toLocaleTimeString(),\n      event.ResourceStatus || '',\n      event.ResourceType,\n      resourceName,\n      logicalId,\n      event.ResourceStatusReason ? event.ResourceStatusReason : '',\n      metadata?.entry.trace ? `\\n\\t${metadata.entry.trace.join('\\n\\t\\\\_ ')}` : '',\n    );\n  }\n}\n\n"]}