@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/payloads/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Assembly data returned in the payload of an IO Message.
+ */
+export interface AssemblyData {
+    /**
+     * The path to the assembly directory
+     */
+    readonly assemblyDirectory: string;
+    /**
+     * The number of stacks actioned on
+     */
+    readonly stacksCount: number;
+    /**
+     * The stack IDs
+     */
+    readonly stackIds: string[];
+}
+/**
+ * Stack data returned in the payload of an IO Message.
+ */
+export interface StackData {
+    /**
+     * The stack name
+     */
+    readonly stackName: string;
+    /**
+     * The stack ID
+     */
+    readonly hierarchicalId: string;
+    /**
+     * The stack template
+     */
+    readonly template: any;
+    /**
+     * The stack template converted to JSON format
+     */
+    readonly stringifiedJson: string;
+    /**
+     * The stack template converted to YAML format
+     */
+    readonly stringifiedYaml: string;
+}
+/**
+ * Stack data returned in the payload of an IO Message.
+ */
+export interface StackAndAssemblyData extends AssemblyData {
+    /**
+     * Stack Data
+     */
+    readonly stack: StackData;
+}
+/**
+ * Duration information returned in the payload of an IO Message.
+ */
+export interface Duration {
+    /**
+     * The duration of the action.
+     */
+    readonly duration: number;
+}
+/**
+ * Generic payload of error IoMessages that pass on an instance of `Error`
+ */
+export interface ErrorPayload {
+    /**
+     * The error that occurred
+     */
+    readonly error: Error;
+}
+/**
+ * Generic payload of a simple yes/no question.
+ *
+ * The expectation is that 'yes' means moving on,
+ * and 'no' means aborting the current action.
+ */
+export interface ConfirmationRequest {
+    /**
+     * Some additional motivation for the confirmation that may be used as context for the user.
+     */
+    readonly motivation: string;
+    /**
+     * Number of on-going concurrent operations
+     * If more than one operations is on-going, a client might decide that asking the user
+     * for input is too complex, as the confirmation might not easily be attributed to a specific request.
+     *
+     * @default - no concurrency
+     */
+    readonly concurrency?: number;
+}
+export interface ContextProviderMessageSource {
+    /**
+     * The name of the context provider sending the message
+     */
+    readonly provider: string;
+}

package/lib/payloads/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/payloads/watch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The computed file watch settings
+ */
+export interface WatchSettings {
+    /**
+     * The directory observed for file changes
+     */
+    readonly watchDir: string;
+    /**
+     * List of include patterns for watching files
+     */
+    readonly includes: string[];
+    /**
+     * List of excludes patterns for watching files
+     */
+    readonly excludes: string[];
+}
+export interface FileWatchEvent {
+    /**
+     * The change to the path
+     */
+    readonly event: string;
+    /**
+     * The path that has an observed event
+     */
+    readonly path?: string;
+}

package/lib/payloads/watch.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ3YXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgY29tcHV0ZWQgZmlsZSB3YXRjaCBzZXR0aW5nc1xuICovXG5leHBvcnQgaW50ZXJmYWNlIFdhdGNoU2V0dGluZ3Mge1xuICAvKipcbiAgICogVGhlIGRpcmVjdG9yeSBvYnNlcnZlZCBmb3IgZmlsZSBjaGFuZ2VzXG4gICAqL1xuICByZWFkb25seSB3YXRjaERpcjogc3RyaW5nO1xuICAvKipcbiAgICogTGlzdCBvZiBpbmNsdWRlIHBhdHRlcm5zIGZvciB3YXRjaGluZyBmaWxlc1xuICAgKi9cbiAgcmVhZG9ubHkgaW5jbHVkZXM6IHN0cmluZ1tdO1xuICAvKipcbiAgICogTGlzdCBvZiBleGNsdWRlcyBwYXR0ZXJucyBmb3Igd2F0Y2hpbmcgZmlsZXNcbiAgICovXG4gIHJlYWRvbmx5IGV4Y2x1ZGVzOiBzdHJpbmdbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGaWxlV2F0Y2hFdmVudCB7XG4gIC8qKlxuICAgKiBUaGUgY2hhbmdlIHRvIHRoZSBwYXRoXG4gICAqL1xuICByZWFkb25seSBldmVudDogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIHBhdGggdGhhdCBoYXMgYW4gb2JzZXJ2ZWQgZXZlbnRcbiAgICovXG4gIHJlYWRvbmx5IHBhdGg/OiBzdHJpbmc7XG59XG4iXX0=

package/lib/private/activity-printer/base.d.ts

@@ -0,0 +1,50 @@
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import type { IoMessage } from '../../api/io';
+import { type StackActivity, type StackProgress } from '../../payloads';
+export interface IActivityPrinter {
+    notify(msg: IoMessage<unknown>): void;
+}
+export interface ActivityPrinterProps {
+    /**
+     * Stream to write to
+     */
+    readonly stream: NodeJS.WriteStream;
+}
+export declare abstract class ActivityPrinterBase implements IActivityPrinter {
+    protected readonly props: ActivityPrinterProps;
+    protected static readonly TIMESTAMP_WIDTH = 12;
+    protected static readonly STATUS_WIDTH = 20;
+    /**
+     * Stream to write to
+     */
+    protected readonly stream: NodeJS.WriteStream;
+    /**
+     * The with of the "resource type" column.
+     */
+    protected resourceTypeColumnWidth: number;
+    /**
+     * A list of resource IDs which are currently being processed
+     */
+    protected resourcesInProgress: Record<string, StackActivity>;
+    protected stackProgress?: StackProgress;
+    protected rollingBack: boolean;
+    protected readonly failures: StackActivity[];
+    protected hookFailureMap: Map<string, Map<string, string>>;
+    constructor(props: ActivityPrinterProps);
+    protected abstract print(): void;
+    /**
+     * Receive a stack activity message
+     */
+    notify(msg: IoMessage<unknown>): void;
+    start({ stack }: {
+        stack: CloudFormationStackArtifact;
+    }): void;
+    activity(activity: StackActivity): void;
+    stop(): void;
+    protected addActivity(activity: StackActivity): void;
+    protected failureReason(activity: StackActivity): string;
+    /**
+     * Is the activity a meta activity for the stack itself.
+     */
+    protected isActivityForTheStack(activity: StackActivity): boolean;
+}

package/lib/private/activity-printer/base.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityPrinterBase = void 0;
+const private_1 = require("../../api/io/private");
+const util_1 = require("../../util");
+class ActivityPrinterBase {
+    props;
+    static TIMESTAMP_WIDTH = 12;
+    static STATUS_WIDTH = 20;
+    /**
+     * Stream to write to
+     */
+    stream;
+    /**
+     * The with of the "resource type" column.
+     */
+    resourceTypeColumnWidth = (0, util_1.maxResourceTypeLength)({});
+    /**
+     * A list of resource IDs which are currently being processed
+     */
+    resourcesInProgress = {};
+    stackProgress;
+    rollingBack = false;
+    failures = new Array();
+    hookFailureMap = new Map();
+    constructor(props) {
+        this.props = props;
+        this.stream = props.stream;
+    }
+    /**
+     * Receive a stack activity message
+     */
+    notify(msg) {
+        switch (true) {
+            case private_1.IO.CDK_TOOLKIT_I5501.is(msg):
+                this.start(msg.data);
+                break;
+            case private_1.IO.CDK_TOOLKIT_I5502.is(msg):
+                this.activity(msg.data);
+                break;
+            case private_1.IO.CDK_TOOLKIT_I5503.is(msg):
+                this.stop();
+                break;
+            default:
+                // ignore all other messages
+                break;
+        }
+    }
+    start({ stack }) {
+        this.resourceTypeColumnWidth = (0, util_1.maxResourceTypeLength)(stack.template);
+    }
+    activity(activity) {
+        // process the activity and then call print
+        this.addActivity(activity);
+        this.print();
+    }
+    stop() {
+        // final print after the stack is done
+        this.print();
+    }
+    addActivity(activity) {
+        const status = activity.event.ResourceStatus;
+        const hookStatus = activity.event.HookStatus;
+        const hookType = activity.event.HookType;
+        if (!status || !activity.event.LogicalResourceId) {
+            return;
+        }
+        this.stackProgress = activity.progress;
+        if (status === 'ROLLBACK_IN_PROGRESS' || status === 'UPDATE_ROLLBACK_IN_PROGRESS') {
+            // Only triggered on the stack once we've started doing a rollback
+            this.rollingBack = true;
+        }
+        if (status.endsWith('_IN_PROGRESS')) {
+            this.resourcesInProgress[activity.event.LogicalResourceId] = activity;
+        }
+        if ((0, util_1.stackEventHasErrorMessage)(status)) {
+            const isCancelled = (activity.event.ResourceStatusReason ?? '').indexOf('cancelled') > -1;
+            // Cancelled is not an interesting failure reason
+            if (!isCancelled) {
+                this.failures.push(activity);
+            }
+        }
+        if (status.endsWith('_COMPLETE') || status.endsWith('_FAILED')) {
+            delete this.resourcesInProgress[activity.event.LogicalResourceId];
+        }
+        if (hookStatus !== undefined &&
+            hookStatus.endsWith('_COMPLETE_FAILED') &&
+            activity.event.LogicalResourceId !== undefined &&
+            hookType !== undefined) {
+            if (this.hookFailureMap.has(activity.event.LogicalResourceId)) {
+                this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? '');
+            }
+            else {
+                this.hookFailureMap.set(activity.event.LogicalResourceId, new Map());
+                this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? '');
+            }
+        }
+    }
+    failureReason(activity) {
+        const resourceStatusReason = activity.event.ResourceStatusReason ?? '';
+        const logicalResourceId = activity.event.LogicalResourceId ?? '';
+        const hookFailureReasonMap = this.hookFailureMap.get(logicalResourceId);
+        if (hookFailureReasonMap !== undefined) {
+            for (const hookType of hookFailureReasonMap.keys()) {
+                if (resourceStatusReason.includes(hookType)) {
+                    return resourceStatusReason + ' : ' + hookFailureReasonMap.get(hookType);
+                }
+            }
+        }
+        return resourceStatusReason;
+    }
+    /**
+     * Is the activity a meta activity for the stack itself.
+     */
+    isActivityForTheStack(activity) {
+        return activity.event.PhysicalResourceId === activity.event.StackId;
+    }
+}
+exports.ActivityPrinterBase = ActivityPrinterBase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["base.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport type { IoMessage } from '../../api/io';\nimport { IO } from '../../api/io/private';\nimport { type StackActivity, type StackProgress } from '../../payloads';\nimport { maxResourceTypeLength, stackEventHasErrorMessage } from '../../util';\n\nexport interface IActivityPrinter {\n  notify(msg: IoMessage<unknown>): void;\n}\n\nexport interface ActivityPrinterProps {\n  /**\n   * Stream to write to\n   */\n  readonly stream: NodeJS.WriteStream;\n}\n\nexport abstract class ActivityPrinterBase implements IActivityPrinter {\n  protected static readonly TIMESTAMP_WIDTH = 12;\n  protected static readonly STATUS_WIDTH = 20;\n\n  /**\n   * Stream to write to\n   */\n  protected readonly stream: NodeJS.WriteStream;\n\n  /**\n   * The with of the \"resource type\" column.\n   */\n  protected resourceTypeColumnWidth: number = maxResourceTypeLength({});\n\n  /**\n   * A list of resource IDs which are currently being processed\n   */\n  protected resourcesInProgress: Record<string, StackActivity> = {};\n\n  protected stackProgress?: StackProgress;\n\n  protected rollingBack = false;\n\n  protected readonly failures = new Array<StackActivity>();\n\n  protected hookFailureMap = new Map<string, Map<string, string>>();\n\n  constructor(protected readonly props: ActivityPrinterProps) {\n    this.stream = props.stream;\n  }\n\n  protected abstract print(): void;\n\n  /**\n   * Receive a stack activity message\n   */\n  public notify(msg: IoMessage<unknown>): void {\n    switch (true) {\n      case IO.CDK_TOOLKIT_I5501.is(msg):\n        this.start(msg.data);\n        break;\n      case IO.CDK_TOOLKIT_I5502.is(msg):\n        this.activity(msg.data);\n        break;\n      case IO.CDK_TOOLKIT_I5503.is(msg):\n        this.stop();\n        break;\n      default:\n        // ignore all other messages\n        break;\n    }\n  }\n\n  public start({ stack }: { stack: CloudFormationStackArtifact}) {\n    this.resourceTypeColumnWidth = maxResourceTypeLength(stack.template);\n  }\n\n  public activity(activity: StackActivity) {\n    // process the activity and then call print\n    this.addActivity(activity);\n    this.print();\n  }\n\n  public stop() {\n    // final print after the stack is done\n    this.print();\n  }\n\n  protected addActivity(activity: StackActivity) {\n    const status = activity.event.ResourceStatus;\n    const hookStatus = activity.event.HookStatus;\n    const hookType = activity.event.HookType;\n    if (!status || !activity.event.LogicalResourceId) {\n      return;\n    }\n\n    this.stackProgress = activity.progress;\n\n    if (status === 'ROLLBACK_IN_PROGRESS' || status === 'UPDATE_ROLLBACK_IN_PROGRESS') {\n      // Only triggered on the stack once we've started doing a rollback\n      this.rollingBack = true;\n    }\n\n    if (status.endsWith('_IN_PROGRESS')) {\n      this.resourcesInProgress[activity.event.LogicalResourceId] = activity;\n    }\n\n    if (stackEventHasErrorMessage(status)) {\n      const isCancelled = (activity.event.ResourceStatusReason ?? '').indexOf('cancelled') > -1;\n\n      // Cancelled is not an interesting failure reason\n      if (!isCancelled) {\n        this.failures.push(activity);\n      }\n    }\n\n    if (status.endsWith('_COMPLETE') || status.endsWith('_FAILED')) {\n      delete this.resourcesInProgress[activity.event.LogicalResourceId];\n    }\n\n    if (\n      hookStatus !== undefined &&\n        hookStatus.endsWith('_COMPLETE_FAILED') &&\n        activity.event.LogicalResourceId !== undefined &&\n        hookType !== undefined\n    ) {\n      if (this.hookFailureMap.has(activity.event.LogicalResourceId)) {\n        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? '');\n      } else {\n        this.hookFailureMap.set(activity.event.LogicalResourceId, new Map<string, string>());\n        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? '');\n      }\n    }\n  }\n\n  protected failureReason(activity: StackActivity) {\n    const resourceStatusReason = activity.event.ResourceStatusReason ?? '';\n    const logicalResourceId = activity.event.LogicalResourceId ?? '';\n    const hookFailureReasonMap = this.hookFailureMap.get(logicalResourceId);\n\n    if (hookFailureReasonMap !== undefined) {\n      for (const hookType of hookFailureReasonMap.keys()) {\n        if (resourceStatusReason.includes(hookType)) {\n          return resourceStatusReason + ' : ' + hookFailureReasonMap.get(hookType);\n        }\n      }\n    }\n    return resourceStatusReason;\n  }\n\n  /**\n   * Is the activity a meta activity for the stack itself.\n   */\n  protected isActivityForTheStack(activity: StackActivity) {\n    return activity.event.PhysicalResourceId === activity.event.StackId;\n  }\n}\n"]}

package/lib/private/activity-printer/current.d.ts

@@ -0,0 +1,26 @@
+import type { ActivityPrinterProps } from './base';
+import { ActivityPrinterBase } from './base';
+/**
+ * Activity Printer which shows the resources currently being updated
+ *
+ * It will continuously re-update the terminal and show only the resources
+ * that are currently being updated, in addition to a progress bar which
+ * shows how far along the deployment is.
+ *
+ * Resources that have failed will always be shown, and will be recapitulated
+ * along with their stack trace when the monitoring ends.
+ *
+ * Resources that failed deployment because they have been cancelled are
+ * not included.
+ */
+export declare class CurrentActivityPrinter extends ActivityPrinterBase {
+    /**
+     * Continuously write to the same output block.
+     */
+    private block;
+    constructor(props: ActivityPrinterProps);
+    protected print(): void;
+    stop(): void;
+    private progressBar;
+    private failureReasonOnNextLine;
+}

package/lib/private/activity-printer/current.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentActivityPrinter = void 0;
+const util = require("util");
+const chalk = require("chalk");
+const base_1 = require("./base");
+const display_1 = require("./display");
+const util_1 = require("../../util");
+/**
+ * Activity Printer which shows the resources currently being updated
+ *
+ * It will continuously re-update the terminal and show only the resources
+ * that are currently being updated, in addition to a progress bar which
+ * shows how far along the deployment is.
+ *
+ * Resources that have failed will always be shown, and will be recapitulated
+ * along with their stack trace when the monitoring ends.
+ *
+ * Resources that failed deployment because they have been cancelled are
+ * not included.
+ */
+class CurrentActivityPrinter extends base_1.ActivityPrinterBase {
+    /**
+     * Continuously write to the same output block.
+     */
+    block;
+    constructor(props) {
+        super(props);
+        this.block = new display_1.RewritableBlock(this.stream);
+    }
+    print() {
+        const lines = [];
+        // Add a progress bar at the top
+        const progressWidth = Math.max(Math.min((this.block.width ?? 80) - PROGRESSBAR_EXTRA_SPACE - 1, MAX_PROGRESSBAR_WIDTH), MIN_PROGRESSBAR_WIDTH);
+        const prog = this.progressBar(progressWidth);
+        if (prog) {
+            lines.push('  ' + prog, '');
+        }
+        // Normally we'd only print "resources in progress", but it's also useful
+        // to keep an eye on the failures and know about the specific errors asquickly
+        // as possible (while the stack is still rolling back), so add those in.
+        const toPrint = [...this.failures, ...Object.values(this.resourcesInProgress)];
+        toPrint.sort((a, b) => a.event.Timestamp.getTime() - b.event.Timestamp.getTime());
+        lines.push(...toPrint.map((res) => {
+            const color = colorFromStatusActivity(res.event.ResourceStatus);
+            const resourceName = res.metadata?.constructPath ?? res.event.LogicalResourceId ?? '';
+            return util.format('%s | %s | %s | %s%s', (0, util_1.padLeft)(CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(res.event.Timestamp).toLocaleTimeString()), color((0, util_1.padRight)(CurrentActivityPrinter.STATUS_WIDTH, (res.event.ResourceStatus || '').slice(0, CurrentActivityPrinter.STATUS_WIDTH))), (0, util_1.padRight)(this.resourceTypeColumnWidth, res.event.ResourceType || ''), color(chalk.bold(shorten(40, resourceName))), this.failureReasonOnNextLine(res));
+        }));
+        this.block.displayLines(lines);
+    }
+    stop() {
+        super.stop();
+        // Print failures at the end
+        const lines = new Array();
+        for (const failure of this.failures) {
+            // Root stack failures are not interesting
+            if (this.isActivityForTheStack(failure)) {
+                continue;
+            }
+            lines.push(util.format(chalk.red('%s | %s | %s | %s%s') + '\n', (0, util_1.padLeft)(CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(failure.event.Timestamp).toLocaleTimeString()), (0, util_1.padRight)(CurrentActivityPrinter.STATUS_WIDTH, (failure.event.ResourceStatus || '').slice(0, CurrentActivityPrinter.STATUS_WIDTH)), (0, util_1.padRight)(this.resourceTypeColumnWidth, failure.event.ResourceType || ''), shorten(40, failure.event.LogicalResourceId ?? ''), this.failureReasonOnNextLine(failure)));
+            const trace = failure.metadata?.entry?.trace;
+            if (trace) {
+                lines.push(chalk.red(`\t${trace.join('\n\t\\_ ')}\n`));
+            }
+        }
+        // Display in the same block space, otherwise we're going to have silly empty lines.
+        this.block.displayLines(lines);
+        this.block.removeEmptyLines();
+    }
+    progressBar(width) {
+        if (!this.stackProgress || !this.stackProgress.total) {
+            return '';
+        }
+        const fraction = Math.min(this.stackProgress.completed / this.stackProgress.total, 1);
+        const innerWidth = Math.max(1, width - 2);
+        const chars = innerWidth * fraction;
+        const remainder = chars - Math.floor(chars);
+        const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
+        const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
+        const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
+        const color = this.rollingBack ? chalk.yellow : chalk.green;
+        return '[' + color(fullChars + partialChar) + filler + `] (${this.stackProgress.completed}/${this.stackProgress.total})`;
+    }
+    failureReasonOnNextLine(activity) {
+        return (0, util_1.stackEventHasErrorMessage)(activity.event.ResourceStatus ?? '')
+            ? `\n${' '.repeat(CurrentActivityPrinter.TIMESTAMP_WIDTH + CurrentActivityPrinter.STATUS_WIDTH + 6)}${chalk.red(this.failureReason(activity) ?? '')}`
+            : '';
+    }
+}
+exports.CurrentActivityPrinter = CurrentActivityPrinter;
+const FULL_BLOCK = '█';
+const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+const MAX_PROGRESSBAR_WIDTH = 60;
+const MIN_PROGRESSBAR_WIDTH = 10;
+const PROGRESSBAR_EXTRA_SPACE = 2 /* leading spaces */ + 2 /* brackets */ + 4 /* progress number decoration */ + 6; /* 2 progress numbers up to 999 */
+function colorFromStatusActivity(status) {
+    if (!status) {
+        return chalk.reset;
+    }
+    if (status.endsWith('_FAILED')) {
+        return chalk.red;
+    }
+    if (status.startsWith('CREATE_') || status.startsWith('UPDATE_') || status.startsWith('IMPORT_')) {
+        return chalk.green;
+    }
+    // For stacks, it may also be 'UPDDATE_ROLLBACK_IN_PROGRESS'
+    if (status.indexOf('ROLLBACK_') !== -1) {
+        return chalk.yellow;
+    }
+    if (status.startsWith('DELETE_')) {
+        return chalk.yellow;
+    }
+    return chalk.reset;
+}
+function shorten(maxWidth, p) {
+    if (p.length <= maxWidth) {
+        return p;
+    }
+    const half = Math.floor((maxWidth - 3) / 2);
+    return p.slice(0, half) + '...' + p.slice(-half);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"current.js","sourceRoot":"","sources":["current.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport * as chalk from 'chalk';\nimport type { ActivityPrinterProps } from './base';\nimport { ActivityPrinterBase } from './base';\nimport { RewritableBlock } from './display';\nimport type { StackActivity } from '../../payloads';\nimport { padLeft, padRight, stackEventHasErrorMessage } from '../../util';\n\n/**\n * Activity Printer which shows the resources currently being updated\n *\n * It will continuously re-update the terminal and show only the resources\n * that are currently being updated, in addition to a progress bar which\n * shows how far along the deployment is.\n *\n * Resources that have failed will always be shown, and will be recapitulated\n * along with their stack trace when the monitoring ends.\n *\n * Resources that failed deployment because they have been cancelled are\n * not included.\n */\nexport class CurrentActivityPrinter extends ActivityPrinterBase {\n  /**\n   * Continuously write to the same output block.\n   */\n  private block: RewritableBlock;\n\n  constructor(props: ActivityPrinterProps) {\n    super(props);\n    this.block = new RewritableBlock(this.stream);\n  }\n\n  protected print(): void {\n    const lines = [];\n\n    // Add a progress bar at the top\n    const progressWidth = Math.max(\n      Math.min((this.block.width ?? 80) - PROGRESSBAR_EXTRA_SPACE - 1, MAX_PROGRESSBAR_WIDTH),\n      MIN_PROGRESSBAR_WIDTH,\n    );\n    const prog = this.progressBar(progressWidth);\n    if (prog) {\n      lines.push('  ' + prog, '');\n    }\n\n    // Normally we'd only print \"resources in progress\", but it's also useful\n    // to keep an eye on the failures and know about the specific errors asquickly\n    // as possible (while the stack is still rolling back), so add those in.\n    const toPrint: StackActivity[] = [...this.failures, ...Object.values(this.resourcesInProgress)];\n    toPrint.sort((a, b) => a.event.Timestamp!.getTime() - b.event.Timestamp!.getTime());\n\n    lines.push(\n      ...toPrint.map((res) => {\n        const color = colorFromStatusActivity(res.event.ResourceStatus);\n        const resourceName = res.metadata?.constructPath ?? res.event.LogicalResourceId ?? '';\n\n        return util.format(\n          '%s | %s | %s | %s%s',\n          padLeft(CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(res.event.Timestamp!).toLocaleTimeString()),\n          color(padRight(CurrentActivityPrinter.STATUS_WIDTH, (res.event.ResourceStatus || '').slice(0, CurrentActivityPrinter.STATUS_WIDTH))),\n          padRight(this.resourceTypeColumnWidth, res.event.ResourceType || ''),\n          color(chalk.bold(shorten(40, resourceName))),\n          this.failureReasonOnNextLine(res),\n        );\n      }),\n    );\n\n    this.block.displayLines(lines);\n  }\n\n  public stop() {\n    super.stop();\n\n    // Print failures at the end\n    const lines = new Array<string>();\n    for (const failure of this.failures) {\n      // Root stack failures are not interesting\n      if (this.isActivityForTheStack(failure)) {\n        continue;\n      }\n\n      lines.push(\n        util.format(\n          chalk.red('%s | %s | %s | %s%s') + '\\n',\n          padLeft(CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(failure.event.Timestamp!).toLocaleTimeString()),\n          padRight(CurrentActivityPrinter.STATUS_WIDTH, (failure.event.ResourceStatus || '').slice(0, CurrentActivityPrinter.STATUS_WIDTH)),\n          padRight(this.resourceTypeColumnWidth, failure.event.ResourceType || ''),\n          shorten(40, failure.event.LogicalResourceId ?? ''),\n          this.failureReasonOnNextLine(failure),\n        ),\n      );\n\n      const trace = failure.metadata?.entry?.trace;\n      if (trace) {\n        lines.push(chalk.red(`\\t${trace.join('\\n\\t\\\\_ ')}\\n`));\n      }\n    }\n\n    // Display in the same block space, otherwise we're going to have silly empty lines.\n    this.block.displayLines(lines);\n    this.block.removeEmptyLines();\n  }\n\n  private progressBar(width: number) {\n    if (!this.stackProgress || !this.stackProgress.total) {\n      return '';\n    }\n    const fraction = Math.min(this.stackProgress.completed / this.stackProgress.total, 1);\n    const innerWidth = Math.max(1, width - 2);\n    const chars = innerWidth * fraction;\n    const remainder = chars - Math.floor(chars);\n\n    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));\n    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];\n    const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));\n\n    const color = this.rollingBack ? chalk.yellow : chalk.green;\n\n    return '[' + color(fullChars + partialChar) + filler + `] (${this.stackProgress.completed}/${this.stackProgress.total})`;\n  }\n\n  private failureReasonOnNextLine(activity: StackActivity) {\n    return stackEventHasErrorMessage(activity.event.ResourceStatus ?? '')\n      ? `\\n${' '.repeat(CurrentActivityPrinter.TIMESTAMP_WIDTH + CurrentActivityPrinter.STATUS_WIDTH + 6)}${chalk.red(this.failureReason(activity) ?? '')}`\n      : '';\n  }\n}\n\nconst FULL_BLOCK = '█';\nconst PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];\nconst MAX_PROGRESSBAR_WIDTH = 60;\nconst MIN_PROGRESSBAR_WIDTH = 10;\nconst PROGRESSBAR_EXTRA_SPACE =\n    2 /* leading spaces */ + 2 /* brackets */ + 4 /* progress number decoration */ + 6; /* 2 progress numbers up to 999 */\n\nfunction colorFromStatusActivity(status?: string) {\n  if (!status) {\n    return chalk.reset;\n  }\n\n  if (status.endsWith('_FAILED')) {\n    return chalk.red;\n  }\n\n  if (status.startsWith('CREATE_') || status.startsWith('UPDATE_') || status.startsWith('IMPORT_')) {\n    return chalk.green;\n  }\n  // For stacks, it may also be 'UPDDATE_ROLLBACK_IN_PROGRESS'\n  if (status.indexOf('ROLLBACK_') !== -1) {\n    return chalk.yellow;\n  }\n  if (status.startsWith('DELETE_')) {\n    return chalk.yellow;\n  }\n\n  return chalk.reset;\n}\n\nfunction shorten(maxWidth: number, p: string) {\n  if (p.length <= maxWidth) {\n    return p;\n  }\n  const half = Math.floor((maxWidth - 3) / 2);\n  return p.slice(0, half) + '...' + p.slice(-half);\n}\n\n"]}

package/lib/private/activity-printer/display.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A class representing rewritable display lines
+ */
+export declare class RewritableBlock {
+    private readonly stream;
+    private lastHeight;
+    private trailingEmptyLines;
+    constructor(stream: NodeJS.WriteStream);
+    get width(): number;
+    get height(): number;
+    displayLines(lines: string[]): void;
+    removeEmptyLines(): void;
+}

package/lib/private/activity-printer/display.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewritableBlock = void 0;
+// namespace object imports won't work in the bundle for function exports
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const wrapAnsi = require('wrap-ansi');
+/**
+ * A class representing rewritable display lines
+ */
+class RewritableBlock {
+    stream;
+    lastHeight = 0;
+    trailingEmptyLines = 0;
+    constructor(stream) {
+        this.stream = stream;
+    }
+    get width() {
+        // Might get changed if the user resizes the terminal
+        return this.stream.columns;
+    }
+    get height() {
+        // Might get changed if the user resizes the terminal
+        return this.stream.rows;
+    }
+    displayLines(lines) {
+        lines = terminalWrap(this.width, expandNewlines(lines));
+        lines = lines.slice(0, getMaxBlockHeight(this.height, this.lastHeight, lines));
+        this.stream.write(cursorUp(this.lastHeight));
+        for (const line of lines) {
+            this.stream.write(cll() + line + '\n');
+        }
+        this.trailingEmptyLines = Math.max(0, this.lastHeight - lines.length);
+        // Clear remainder of unwritten lines
+        for (let i = 0; i < this.trailingEmptyLines; i++) {
+            this.stream.write(cll() + '\n');
+        }
+        // The block can only ever get bigger
+        this.lastHeight = Math.max(this.lastHeight, lines.length);
+    }
+    removeEmptyLines() {
+        this.stream.write(cursorUp(this.trailingEmptyLines));
+    }
+}
+exports.RewritableBlock = RewritableBlock;
+const ESC = '\u001b';
+/*
+ * Move cursor up `n` lines. Default is 1
+ */
+function cursorUp(n) {
+    n = typeof n === 'number' ? n : 1;
+    return n > 0 ? ESC + '[' + n + 'A' : '';
+}
+/**
+ * Clear to end of line
+ */
+function cll() {
+    return ESC + '[K';
+}
+function terminalWrap(width, lines) {
+    if (width === undefined) {
+        return lines;
+    }
+    return lines.flatMap(line => wrapAnsi(line, width - 1, {
+        hard: true,
+        trim: true,
+        wordWrap: false,
+    }).split('\n'));
+}
+/**
+ * Make sure there are no hidden newlines in the gin strings
+ */
+function expandNewlines(lines) {
+    return lines.flatMap(line => line.split('\n'));
+}
+function getMaxBlockHeight(windowHeight, lastHeight, lines) {
+    if (windowHeight === undefined) {
+        return Math.max(lines.length, lastHeight);
+    }
+    return lines.length < windowHeight ? lines.length : windowHeight - 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/activity-printer/history.d.ts

@@ -0,0 +1,32 @@
+import type { ActivityPrinterProps } from './base';
+import { ActivityPrinterBase } from './base';
+import type { StackActivity } from '../../payloads';
+/**
+ * Activity Printer which shows a full log of all CloudFormation events
+ *
+ * When there hasn't been activity for a while, it will print the resources
+ * that are currently in progress, to show what's holding up the deployment.
+ */
+export declare class HistoryActivityPrinter extends ActivityPrinterBase {
+    /**
+     * Last time we printed something to the console.
+     *
+     * Used to measure timeout for progress reporting.
+     */
+    private lastPrintTime;
+    private lastPrinted?;
+    /**
+     * Number of ms of change absence before we tell the user about the resources that are currently in progress.
+     */
+    private readonly inProgressDelay;
+    private readonly printable;
+    constructor(props: ActivityPrinterProps);
+    activity(activity: StackActivity): void;
+    stop(): void;
+    protected print(): void;
+    private printOne;
+    /**
+     * If some resources are taking a while to create, notify the user about what's currently in progress
+     */
+    private printInProgress;
+}