@aws-cdk/toolkit-lib 0.3.3 → 0.3.5

package/lib/api/notices/filter.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredNotice = exports.NoticesFilter = void 0;
+const semver = require("semver");
+const private_1 = require("../io/private");
+const tree_1 = require("../tree");
+/**
+ * Normalizes the given components structure into DNF form
+ */
+function normalizeComponents(xs) {
+    return xs.map(x => Array.isArray(x) ? x : [x]);
+}
+function renderConjunction(xs) {
+    return xs.map(c => `${c.name}: ${c.version}`).join(' AND ');
+}
+class NoticesFilter {
+    ioMessages;
+    constructor(ioMessages) {
+        this.ioMessages = ioMessages;
+    }
+    filter(options) {
+        const components = [
+            ...this.constructTreeComponents(options.outDir),
+            ...this.otherComponents(options),
+        ];
+        return this.findForNamedComponents(options.data, components);
+    }
+    /**
+     * From a set of input options, return the notices components we are searching for
+     */
+    otherComponents(options) {
+        return [
+            // CLI
+            {
+                name: 'cli',
+                version: options.cliVersion,
+            },
+            // Node version
+            {
+                name: 'node',
+                version: process.version.replace(/^v/, ''), // remove the 'v' prefix.
+                dynamicName: 'node',
+            },
+            // Bootstrap environments
+            ...options.bootstrappedEnvironments.flatMap(env => {
+                const semverBootstrapVersion = semver.coerce(env.bootstrapStackVersion);
+                if (!semverBootstrapVersion) {
+                    // we don't throw because notices should never crash the cli.
+                    this.ioMessages.warning(`While filtering notices, could not coerce bootstrap version '${env.bootstrapStackVersion}' into semver`);
+                    return [];
+                }
+                return [{
+                        name: 'bootstrap',
+                        version: `${semverBootstrapVersion}`,
+                        dynamicName: 'ENVIRONMENTS',
+                        dynamicValue: env.environment.name,
+                    }];
+            }),
+        ];
+    }
+    /**
+     * Based on a set of component names, find all notices that match one of the given components
+     */
+    findForNamedComponents(data, actualComponents) {
+        return data.flatMap(notice => {
+            const ors = this.resolveAliases(normalizeComponents(notice.components));
+            // Find the first set of the disjunctions of which all components match against the actual components.
+            // Return the actual components we found so that we can inject their dynamic values. A single filter
+            // component can match more than one actual component
+            for (const ands of ors) {
+                const matched = ands.map(affected => actualComponents.filter(actual => this.componentNameMatches(affected, actual) && semver.satisfies(actual.version, affected.version, { includePrerelease: true })));
+                // For every clause in the filter we matched one or more components
+                if (matched.every(xs => xs.length > 0)) {
+                    const ret = new FilteredNotice(notice);
+                    this.addDynamicValues(matched.flatMap(x => x), ret);
+                    return [ret];
+                }
+            }
+            return [];
+        });
+    }
+    /**
+     * Whether the given "affected component" name applies to the given actual component name.
+     *
+     * The name matches if the name is exactly the same, or the name in the notice
+     * is a prefix of the node name when the query ends in '.'.
+     */
+    componentNameMatches(pattern, actual) {
+        return pattern.name.endsWith('.') ? actual.name.startsWith(pattern.name) : pattern.name === actual.name;
+    }
+    /**
+     * Adds dynamic values from the given ActualComponents
+     *
+     * If there are multiple components with the same dynamic name, they are joined
+     * by a comma.
+     */
+    addDynamicValues(comps, notice) {
+        const dynamicValues = {};
+        for (const comp of comps) {
+            if (comp.dynamicName) {
+                dynamicValues[comp.dynamicName] = dynamicValues[comp.dynamicName] ?? [];
+                dynamicValues[comp.dynamicName].push(comp.dynamicValue ?? comp.version);
+            }
+        }
+        for (const [key, values] of Object.entries(dynamicValues)) {
+            notice.addDynamicValue(key, values.join(','));
+        }
+    }
+    /**
+     * Treat 'framework' as an alias for either `aws-cdk-lib.` or `@aws-cdk/core.`.
+     *
+     * Because it's EITHER `aws-cdk-lib` or `@aws-cdk/core`, we need to add multiple
+     * arrays at the top level.
+     */
+    resolveAliases(ors) {
+        return ors.flatMap(ands => {
+            const hasFramework = ands.find(c => c.name === 'framework');
+            if (!hasFramework) {
+                return [ands];
+            }
+            return [
+                ands.map(c => c.name === 'framework' ? { ...c, name: '@aws-cdk/core.' } : c),
+                ands.map(c => c.name === 'framework' ? { ...c, name: 'aws-cdk-lib.' } : c),
+            ];
+        });
+    }
+    /**
+     * Load the construct tree from the given directory and return its components
+     */
+    constructTreeComponents(manifestDir) {
+        const tree = (0, tree_1.loadTreeFromDir)(manifestDir, (msg) => void this.ioMessages.notify(private_1.IO.DEFAULT_ASSEMBLY_TRACE.msg(msg)));
+        if (!tree) {
+            return [];
+        }
+        const ret = [];
+        recurse(tree);
+        return ret;
+        function recurse(x) {
+            if (x.constructInfo?.fqn && x.constructInfo?.version) {
+                ret.push({
+                    name: x.constructInfo?.fqn,
+                    version: x.constructInfo?.version,
+                });
+            }
+            for (const child of Object.values(x.children ?? {})) {
+                recurse(child);
+            }
+        }
+    }
+}
+exports.NoticesFilter = NoticesFilter;
+/**
+ * Notice after passing the filter. A filter can augment a notice with
+ * dynamic values as it has access to the dynamic matching data.
+ */
+class FilteredNotice {
+    notice;
+    dynamicValues = {};
+    constructor(notice) {
+        this.notice = notice;
+    }
+    addDynamicValue(key, value) {
+        this.dynamicValues[`{resolve:${key}}`] = value;
+    }
+    format() {
+        const componentsValue = normalizeComponents(this.notice.components).map(renderConjunction).join(', ');
+        return this.resolveDynamicValues([
+            `${this.notice.issueNumber}\t${this.notice.title}`,
+            this.formatOverview(),
+            `\tAffected versions: ${componentsValue}`,
+            `\tMore information at: https://github.com/aws/aws-cdk/issues/${this.notice.issueNumber}`,
+        ].join('\n\n') + '\n');
+    }
+    formatOverview() {
+        const wrap = (s) => s.replace(/(?![^\n]{1,60}$)([^\n]{1,60})\s/g, '$1\n');
+        const heading = 'Overview: ';
+        const separator = `\n\t${' '.repeat(heading.length)}`;
+        const content = wrap(this.notice.overview)
+            .split('\n')
+            .join(separator);
+        return '\t' + heading + content;
+    }
+    resolveDynamicValues(input) {
+        const pattern = new RegExp(Object.keys(this.dynamicValues).join('|'), 'g');
+        return input.replace(pattern, (matched) => this.dynamicValues[matched] ?? matched);
+    }
+}
+exports.FilteredNotice = FilteredNotice;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.js","sourceRoot":"","sources":["filter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as semver from 'semver';\nimport { IO, type IoDefaultMessages } from '../io/private';\nimport type { ConstructTreeNode } from '../tree';\nimport { loadTreeFromDir } from '../tree';\nimport type { BootstrappedEnvironment, Component, Notice } from './types';\n\n/**\n * Normalizes the given components structure into DNF form\n */\nfunction normalizeComponents(xs: Array<Component | Component[]>): Component[][] {\n  return xs.map(x => Array.isArray(x) ? x : [x]);\n}\n\nfunction renderConjunction(xs: Component[]): string {\n  return xs.map(c => `${c.name}: ${c.version}`).join(' AND ');\n}\n\ninterface ActualComponent {\n  /**\n   * Name of the component\n   */\n  readonly name: string;\n\n  /**\n   * Version of the component\n   */\n  readonly version: string;\n\n  /**\n   * If matched, under what name should it be added to the set of dynamic values\n   *\n   * These will be used to substitute placeholders in the message string, where\n   * placeholders look like `{resolve:XYZ}`.\n   *\n   * If there is more than one component with the same dynamic name, they are\n   * joined by ','.\n   *\n   * @default - Don't add to the set of dynamic values.\n   */\n  readonly dynamicName?: string;\n\n  /**\n   * If matched, what we should put in the set of dynamic values insstead of the version.\n   *\n   * Only used if `dynamicName` is set; by default we will add the actual version\n   * of the component.\n   *\n   * @default - The version.\n   */\n  readonly dynamicValue?: string;\n}\n\nexport interface NoticesFilterFilterOptions {\n  readonly data: Notice[];\n  readonly cliVersion: string;\n  readonly outDir: string;\n  readonly bootstrappedEnvironments: BootstrappedEnvironment[];\n}\n\nexport class NoticesFilter {\n  constructor(private readonly ioMessages: IoDefaultMessages) {\n  }\n\n  public filter(options: NoticesFilterFilterOptions): FilteredNotice[] {\n    const components = [\n      ...this.constructTreeComponents(options.outDir),\n      ...this.otherComponents(options),\n    ];\n\n    return this.findForNamedComponents(options.data, components);\n  }\n\n  /**\n   * From a set of input options, return the notices components we are searching for\n   */\n  private otherComponents(options: NoticesFilterFilterOptions): ActualComponent[] {\n    return [\n      // CLI\n      {\n        name: 'cli',\n        version: options.cliVersion,\n      },\n\n      // Node version\n      {\n        name: 'node',\n        version: process.version.replace(/^v/, ''), // remove the 'v' prefix.\n        dynamicName: 'node',\n      },\n\n      // Bootstrap environments\n      ...options.bootstrappedEnvironments.flatMap(env => {\n        const semverBootstrapVersion = semver.coerce(env.bootstrapStackVersion);\n        if (!semverBootstrapVersion) {\n          // we don't throw because notices should never crash the cli.\n          this.ioMessages.warning(`While filtering notices, could not coerce bootstrap version '${env.bootstrapStackVersion}' into semver`);\n          return [];\n        }\n\n        return [{\n          name: 'bootstrap',\n          version: `${semverBootstrapVersion}`,\n          dynamicName: 'ENVIRONMENTS',\n          dynamicValue: env.environment.name,\n        }];\n      }),\n    ];\n  }\n\n  /**\n   * Based on a set of component names, find all notices that match one of the given components\n   */\n  private findForNamedComponents(data: Notice[], actualComponents: ActualComponent[]): FilteredNotice[] {\n    return data.flatMap(notice => {\n      const ors = this.resolveAliases(normalizeComponents(notice.components));\n\n      // Find the first set of the disjunctions of which all components match against the actual components.\n      // Return the actual components we found so that we can inject their dynamic values. A single filter\n      // component can match more than one actual component\n      for (const ands of ors) {\n        const matched = ands.map(affected => actualComponents.filter(actual =>\n          this.componentNameMatches(affected, actual) && semver.satisfies(actual.version, affected.version, { includePrerelease: true })));\n\n        // For every clause in the filter we matched one or more components\n        if (matched.every(xs => xs.length > 0)) {\n          const ret = new FilteredNotice(notice);\n          this.addDynamicValues(matched.flatMap(x => x), ret);\n          return [ret];\n        }\n      }\n\n      return [];\n    });\n  }\n\n  /**\n   * Whether the given \"affected component\" name applies to the given actual component name.\n   *\n   * The name matches if the name is exactly the same, or the name in the notice\n   * is a prefix of the node name when the query ends in '.'.\n   */\n  private componentNameMatches(pattern: Component, actual: ActualComponent): boolean {\n    return pattern.name.endsWith('.') ? actual.name.startsWith(pattern.name) : pattern.name === actual.name;\n  }\n\n  /**\n   * Adds dynamic values from the given ActualComponents\n   *\n   * If there are multiple components with the same dynamic name, they are joined\n   * by a comma.\n   */\n  private addDynamicValues(comps: ActualComponent[], notice: FilteredNotice) {\n    const dynamicValues: Record<string, string[]> = {};\n    for (const comp of comps) {\n      if (comp.dynamicName) {\n        dynamicValues[comp.dynamicName] = dynamicValues[comp.dynamicName] ?? [];\n        dynamicValues[comp.dynamicName].push(comp.dynamicValue ?? comp.version);\n      }\n    }\n    for (const [key, values] of Object.entries(dynamicValues)) {\n      notice.addDynamicValue(key, values.join(','));\n    }\n  }\n\n  /**\n   * Treat 'framework' as an alias for either `aws-cdk-lib.` or `@aws-cdk/core.`.\n   *\n   * Because it's EITHER `aws-cdk-lib` or `@aws-cdk/core`, we need to add multiple\n   * arrays at the top level.\n   */\n  private resolveAliases(ors: Component[][]): Component[][] {\n    return ors.flatMap(ands => {\n      const hasFramework = ands.find(c => c.name === 'framework');\n      if (!hasFramework) {\n        return [ands];\n      }\n\n      return [\n        ands.map(c => c.name === 'framework' ? { ...c, name: '@aws-cdk/core.' } : c),\n        ands.map(c => c.name === 'framework' ? { ...c, name: 'aws-cdk-lib.' } : c),\n      ];\n    });\n  }\n\n  /**\n   * Load the construct tree from the given directory and return its components\n   */\n  private constructTreeComponents(manifestDir: string): ActualComponent[] {\n    const tree = loadTreeFromDir(manifestDir, (msg: string) => void this.ioMessages.notify(IO.DEFAULT_ASSEMBLY_TRACE.msg(msg)));\n    if (!tree) {\n      return [];\n    }\n\n    const ret: ActualComponent[] = [];\n    recurse(tree);\n    return ret;\n\n    function recurse(x: ConstructTreeNode) {\n      if (x.constructInfo?.fqn && x.constructInfo?.version) {\n        ret.push({\n          name: x.constructInfo?.fqn,\n          version: x.constructInfo?.version,\n        });\n      }\n\n      for (const child of Object.values(x.children ?? {})) {\n        recurse(child);\n      }\n    }\n  }\n}\n\n/**\n * Notice after passing the filter. A filter can augment a notice with\n * dynamic values as it has access to the dynamic matching data.\n */\nexport class FilteredNotice {\n  private readonly dynamicValues: { [key: string]: string } = {};\n\n  public constructor(public readonly notice: Notice) {\n  }\n\n  public addDynamicValue(key: string, value: string) {\n    this.dynamicValues[`{resolve:${key}}`] = value;\n  }\n\n  public format(): string {\n    const componentsValue = normalizeComponents(this.notice.components).map(renderConjunction).join(', ');\n    return this.resolveDynamicValues([\n      `${this.notice.issueNumber}\\t${this.notice.title}`,\n      this.formatOverview(),\n      `\\tAffected versions: ${componentsValue}`,\n      `\\tMore information at: https://github.com/aws/aws-cdk/issues/${this.notice.issueNumber}`,\n    ].join('\\n\\n') + '\\n');\n  }\n\n  private formatOverview() {\n    const wrap = (s: string) => s.replace(/(?![^\\n]{1,60}$)([^\\n]{1,60})\\s/g, '$1\\n');\n\n    const heading = 'Overview: ';\n    const separator = `\\n\\t${' '.repeat(heading.length)}`;\n    const content = wrap(this.notice.overview)\n      .split('\\n')\n      .join(separator);\n\n    return '\\t' + heading + content;\n  }\n\n  private resolveDynamicValues(input: string): string {\n    const pattern = new RegExp(Object.keys(this.dynamicValues).join('|'), 'g');\n    return input.replace(pattern, (matched) => this.dynamicValues[matched] ?? matched);\n  }\n}\n"]}

package/lib/api/notices/index.d.ts

@@ -0,0 +1 @@
+export * from './notices';

package/lib/api/{private.js → notices/index.js}

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./io/private"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInByaXZhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW8vcHJpdmF0ZSc7XG4iXX0=
+__exportStar(require("./notices"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNENBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ub3RpY2VzJztcbiJdfQ==

package/lib/api/notices/notices.d.ts

@@ -0,0 +1,111 @@
+import type { SdkHttpOptions } from '../aws-auth';
+import type { Context } from '../context';
+import type { IIoHost } from '../io';
+import type { FilteredNotice } from './filter';
+import type { BootstrappedEnvironment, NoticeDataSource } from './types';
+export interface NoticesProps {
+    /**
+     * CDK context
+     */
+    readonly context: Context;
+    /**
+     * Global CLI option for output directory for synthesized cloud assembly
+     *
+     * @default 'cdk.out'
+     */
+    readonly output?: string;
+    /**
+     * Options for the HTTP request
+     */
+    readonly httpOptions?: SdkHttpOptions;
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * The version of the CLI
+     */
+    readonly cliVersion: string;
+}
+export interface NoticesFilterOptions {
+    /**
+     * Include notices that have already been acknowledged.
+     *
+     * @default false
+     */
+    readonly includeAcknowledged?: boolean;
+}
+export interface NoticesDisplayOptions extends NoticesFilterOptions {
+    /**
+     * Whether to append the total number of unacknowledged notices to the display.
+     *
+     * @default false
+     */
+    readonly showTotal?: boolean;
+}
+export interface NoticesRefreshOptions {
+    /**
+     * Whether to force a cache refresh regardless of expiration time.
+     *
+     * @default false
+     */
+    readonly force?: boolean;
+    /**
+     * Data source for fetch notices from.
+     *
+     * @default - WebsiteNoticeDataSource
+     */
+    readonly dataSource?: NoticeDataSource;
+}
+/**
+ * Provides access to notices the CLI can display.
+ */
+export declare class Notices {
+    /**
+     * Create an instance. Note that this replaces the singleton.
+     */
+    static create(props: NoticesProps): Notices;
+    /**
+     * Get the singleton instance. May return `undefined` if `create` has not been called.
+     */
+    static get(): Notices | undefined;
+    private static _instance;
+    private readonly context;
+    private readonly output;
+    private readonly acknowledgedIssueNumbers;
+    private readonly httpOptions;
+    private readonly ioHelper;
+    private readonly ioMessages;
+    private readonly cliVersion;
+    private data;
+    private readonly bootstrappedEnvironments;
+    private constructor();
+    /**
+     * Add a bootstrap information to filter on. Can have multiple values
+     * in case of multi-environment deployments.
+     */
+    addBootstrappedEnvironment(bootstrapped: BootstrappedEnvironment): void;
+    /**
+     * Refresh the list of notices this instance is aware of.
+     *
+     * This method throws an error if the data source fails to fetch notices.
+     * When using, consider if execution should halt immdiately or if catching the rror and continuing is more appropriate
+     *
+     * @throws on failure to refresh the data source
+     */
+    refresh(options?: NoticesRefreshOptions): Promise<void>;
+    /**
+     * Filter the data sourece for relevant notices
+     */
+    filter(options?: NoticesDisplayOptions): FilteredNotice[];
+    /**
+     * Display the relevant notices (unless context dictates we shouldn't).
+     */
+    display(options?: NoticesDisplayOptions): Promise<void>;
+    /**
+     * List all notices available in the data source.
+     *
+     * @param includeAcknowlegded Whether to include acknowledged notices.
+     */
+    private noticesFromData;
+}

package/lib/api/notices/notices.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notices = void 0;
+const path = require("path");
+const util_1 = require("../../util");
+const cached_data_source_1 = require("./cached-data-source");
+const filter_1 = require("./filter");
+const web_data_source_1 = require("./web-data-source");
+const private_1 = require("../io/private");
+const CACHE_FILE_PATH = path.join((0, util_1.cdkCacheDir)(), 'notices.json');
+/**
+ * Provides access to notices the CLI can display.
+ */
+class Notices {
+    /**
+     * Create an instance. Note that this replaces the singleton.
+     */
+    static create(props) {
+        this._instance = new Notices(props);
+        return this._instance;
+    }
+    /**
+     * Get the singleton instance. May return `undefined` if `create` has not been called.
+     */
+    static get() {
+        return this._instance;
+    }
+    static _instance;
+    context;
+    output;
+    acknowledgedIssueNumbers;
+    httpOptions;
+    ioHelper;
+    ioMessages;
+    cliVersion;
+    data = new Set();
+    // sets don't deduplicate interfaces, so we use a map.
+    bootstrappedEnvironments = new Map();
+    constructor(props) {
+        this.context = props.context;
+        this.acknowledgedIssueNumbers = new Set(this.context.get('acknowledged-issue-numbers') ?? []);
+        this.output = props.output ?? 'cdk.out';
+        this.httpOptions = props.httpOptions ?? {};
+        this.ioHelper = (0, private_1.asIoHelper)(props.ioHost, 'notices' /* forcing a CliAction to a ToolkitAction */);
+        this.ioMessages = new private_1.IoDefaultMessages(this.ioHelper);
+        this.cliVersion = props.cliVersion;
+    }
+    /**
+     * Add a bootstrap information to filter on. Can have multiple values
+     * in case of multi-environment deployments.
+     */
+    addBootstrappedEnvironment(bootstrapped) {
+        const key = [
+            bootstrapped.bootstrapStackVersion,
+            bootstrapped.environment.account,
+            bootstrapped.environment.region,
+            bootstrapped.environment.name,
+        ].join(':');
+        this.bootstrappedEnvironments.set(key, bootstrapped);
+    }
+    /**
+     * Refresh the list of notices this instance is aware of.
+     *
+     * This method throws an error if the data source fails to fetch notices.
+     * When using, consider if execution should halt immdiately or if catching the rror and continuing is more appropriate
+     *
+     * @throws on failure to refresh the data source
+     */
+    async refresh(options = {}) {
+        const innerDataSource = options.dataSource ?? new web_data_source_1.WebsiteNoticeDataSource(this.ioHelper, this.httpOptions);
+        const dataSource = new cached_data_source_1.CachedDataSource(this.ioMessages, CACHE_FILE_PATH, innerDataSource, options.force ?? false);
+        const notices = await dataSource.fetch();
+        this.data = new Set(notices);
+    }
+    /**
+     * Filter the data sourece for relevant notices
+     */
+    filter(options = {}) {
+        return new filter_1.NoticesFilter(this.ioMessages).filter({
+            data: this.noticesFromData(options.includeAcknowledged ?? false),
+            cliVersion: this.cliVersion,
+            outDir: this.output,
+            bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values()),
+        });
+    }
+    /**
+     * Display the relevant notices (unless context dictates we shouldn't).
+     */
+    async display(options = {}) {
+        const filteredNotices = this.filter(options);
+        if (filteredNotices.length > 0) {
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I0100.msg([
+                '',
+                'NOTICES         (What\'s this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)',
+                '',
+            ].join('\n')));
+            for (const filtered of filteredNotices) {
+                const formatted = filtered.format() + '\n';
+                switch (filtered.notice.severity) {
+                    case 'warning':
+                        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_W0101.msg(formatted));
+                        break;
+                    case 'error':
+                        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_E0101.msg(formatted));
+                        break;
+                    default:
+                        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I0101.msg(formatted));
+                        break;
+                }
+            }
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I0100.msg(`If you don’t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`));
+        }
+        if (options.showTotal ?? false) {
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I0100.msg(`\nThere are ${filteredNotices.length} unacknowledged notice(s).`));
+        }
+    }
+    /**
+     * List all notices available in the data source.
+     *
+     * @param includeAcknowlegded Whether to include acknowledged notices.
+     */
+    noticesFromData(includeAcknowlegded = false) {
+        const data = Array.from(this.data);
+        if (includeAcknowlegded) {
+            return data;
+        }
+        return data.filter(n => !this.acknowledgedIssueNumbers.has(n.issueNumber));
+    }
+}
+exports.Notices = Notices;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notices.js","sourceRoot":"","sources":["notices.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { cdkCacheDir } from '../../util';\nimport type { SdkHttpOptions } from '../aws-auth';\nimport type { Context } from '../context';\nimport type { IIoHost } from '../io';\nimport { CachedDataSource } from './cached-data-source';\nimport type { FilteredNotice } from './filter';\nimport { NoticesFilter } from './filter';\nimport type { BootstrappedEnvironment, Notice, NoticeDataSource } from './types';\nimport { WebsiteNoticeDataSource } from './web-data-source';\nimport type { IoHelper } from '../io/private';\nimport { IO, asIoHelper, IoDefaultMessages } from '../io/private';\n\nconst CACHE_FILE_PATH = path.join(cdkCacheDir(), 'notices.json');\n\nexport interface NoticesProps {\n  /**\n   * CDK context\n   */\n  readonly context: Context;\n\n  /**\n   * Global CLI option for output directory for synthesized cloud assembly\n   *\n   * @default 'cdk.out'\n   */\n  readonly output?: string;\n\n  /**\n   * Options for the HTTP request\n   */\n  readonly httpOptions?: SdkHttpOptions;\n\n  /**\n   * Where messages are going to be sent\n   */\n  readonly ioHost: IIoHost;\n\n  /**\n   * The version of the CLI\n   */\n  readonly cliVersion: string;\n}\n\nexport interface NoticesFilterOptions {\n  /**\n   * Include notices that have already been acknowledged.\n   *\n   * @default false\n   */\n  readonly includeAcknowledged?: boolean;\n}\n\nexport interface NoticesDisplayOptions extends NoticesFilterOptions {\n  /**\n   * Whether to append the total number of unacknowledged notices to the display.\n   *\n   * @default false\n   */\n  readonly showTotal?: boolean;\n}\n\nexport interface NoticesRefreshOptions {\n  /**\n   * Whether to force a cache refresh regardless of expiration time.\n   *\n   * @default false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Data source for fetch notices from.\n   *\n   * @default - WebsiteNoticeDataSource\n   */\n  readonly dataSource?: NoticeDataSource;\n}\n\n/**\n * Provides access to notices the CLI can display.\n */\nexport class Notices {\n  /**\n   * Create an instance. Note that this replaces the singleton.\n   */\n  public static create(props: NoticesProps): Notices {\n    this._instance = new Notices(props);\n    return this._instance;\n  }\n\n  /**\n   * Get the singleton instance. May return `undefined` if `create` has not been called.\n   */\n  public static get(): Notices | undefined {\n    return this._instance;\n  }\n\n  private static _instance: Notices | undefined;\n\n  private readonly context: Context;\n  private readonly output: string;\n  private readonly acknowledgedIssueNumbers: Set<Number>;\n  private readonly httpOptions: SdkHttpOptions;\n  private readonly ioHelper: IoHelper;\n  private readonly ioMessages: IoDefaultMessages;\n  private readonly cliVersion: string;\n\n  private data: Set<Notice> = new Set();\n\n  // sets don't deduplicate interfaces, so we use a map.\n  private readonly bootstrappedEnvironments: Map<string, BootstrappedEnvironment> = new Map();\n\n  private constructor(props: NoticesProps) {\n    this.context = props.context;\n    this.acknowledgedIssueNumbers = new Set(this.context.get('acknowledged-issue-numbers') ?? []);\n    this.output = props.output ?? 'cdk.out';\n    this.httpOptions = props.httpOptions ?? {};\n    this.ioHelper = asIoHelper(props.ioHost, 'notices' as any /* forcing a CliAction to a ToolkitAction */);\n    this.ioMessages = new IoDefaultMessages(this.ioHelper);\n    this.cliVersion = props.cliVersion;\n  }\n\n  /**\n   * Add a bootstrap information to filter on. Can have multiple values\n   * in case of multi-environment deployments.\n   */\n  public addBootstrappedEnvironment(bootstrapped: BootstrappedEnvironment) {\n    const key = [\n      bootstrapped.bootstrapStackVersion,\n      bootstrapped.environment.account,\n      bootstrapped.environment.region,\n      bootstrapped.environment.name,\n    ].join(':');\n    this.bootstrappedEnvironments.set(key, bootstrapped);\n  }\n\n  /**\n   * Refresh the list of notices this instance is aware of.\n   *\n   * This method throws an error if the data source fails to fetch notices.\n   * When using, consider if execution should halt immdiately or if catching the rror and continuing is more appropriate\n   *\n   * @throws on failure to refresh the data source\n   */\n  public async refresh(options: NoticesRefreshOptions = {}) {\n    const innerDataSource = options.dataSource ?? new WebsiteNoticeDataSource(this.ioHelper, this.httpOptions);\n    const dataSource = new CachedDataSource(this.ioMessages, CACHE_FILE_PATH, innerDataSource, options.force ?? false);\n    const notices = await dataSource.fetch();\n    this.data = new Set(notices);\n  }\n\n  /**\n   * Filter the data sourece for relevant notices\n   */\n  public filter(options: NoticesDisplayOptions = {}): FilteredNotice[] {\n    return new NoticesFilter(this.ioMessages).filter({\n      data: this.noticesFromData(options.includeAcknowledged ?? false),\n      cliVersion: this.cliVersion,\n      outDir: this.output,\n      bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values()),\n    });\n  }\n\n  /**\n   * Display the relevant notices (unless context dictates we shouldn't).\n   */\n  public async display(options: NoticesDisplayOptions = {}): Promise<void> {\n    const filteredNotices = this.filter(options);\n\n    if (filteredNotices.length > 0) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I0100.msg([\n        '',\n        'NOTICES         (What\\'s this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)',\n        '',\n      ].join('\\n')));\n      for (const filtered of filteredNotices) {\n        const formatted = filtered.format() + '\\n';\n        switch (filtered.notice.severity) {\n          case 'warning':\n            await this.ioHelper.notify(IO.CDK_TOOLKIT_W0101.msg(formatted));\n            break;\n          case 'error':\n            await this.ioHelper.notify(IO.CDK_TOOLKIT_E0101.msg(formatted));\n            break;\n          default:\n            await this.ioHelper.notify(IO.CDK_TOOLKIT_I0101.msg(formatted));\n            break;\n        }\n      }\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I0100.msg(\n        `If you don’t want to see a notice anymore, use \"cdk acknowledge <id>\". For example, \"cdk acknowledge ${filteredNotices[0].notice.issueNumber}\".`,\n      ));\n    }\n\n    if (options.showTotal ?? false) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I0100.msg(\n        `\\nThere are ${filteredNotices.length} unacknowledged notice(s).`,\n      ));\n    }\n  }\n\n  /**\n   * List all notices available in the data source.\n   *\n   * @param includeAcknowlegded Whether to include acknowledged notices.\n   */\n  private noticesFromData(includeAcknowlegded = false): Notice[] {\n    const data = Array.from(this.data);\n\n    if (includeAcknowlegded) {\n      return data;\n    }\n\n    return data.filter(n => !this.acknowledgedIssueNumbers.has(n.issueNumber));\n  }\n}\n\n"]}

package/lib/api/notices/types.d.ts

@@ -0,0 +1,37 @@
+import type { Environment } from '@aws-cdk/cx-api';
+export interface Component {
+    name: string;
+    /**
+     * The range of affected versions
+     */
+    version: string;
+}
+export interface Notice {
+    title: string;
+    issueNumber: number;
+    overview: string;
+    /**
+     * A set of affected components
+     *
+     * The canonical form of a list of components is in Disjunctive Normal Form
+     * (i.e., an OR of ANDs). This is the form when the list of components is a
+     * doubly nested array: the notice matches if all components of at least one
+     * of the top-level array matches.
+     *
+     * If the `components` is a single-level array, it is evaluated as an OR; it
+     * matches if any of the components matches.
+     */
+    components: Array<Component | Component[]>;
+    schemaVersion: string;
+    severity?: string;
+}
+export interface NoticeDataSource {
+    fetch(): Promise<Notice[]>;
+}
+/**
+ * Information about a bootstrapped environment.
+ */
+export interface BootstrappedEnvironment {
+    readonly bootstrapStackVersion: number;
+    readonly environment: Environment;
+}

package/lib/api/notices/types.js

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

package/lib/api/notices/web-data-source.d.ts

@@ -0,0 +1,9 @@
+import type { SdkHttpOptions } from '../aws-auth';
+import type { Notice, NoticeDataSource } from './types';
+import type { IoHelper } from '../io/private';
+export declare class WebsiteNoticeDataSource implements NoticeDataSource {
+    private readonly ioHelper;
+    private readonly options;
+    constructor(ioHelper: IoHelper, options?: SdkHttpOptions);
+    fetch(): Promise<Notice[]>;
+}

package/lib/api/notices/web-data-source.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsiteNoticeDataSource = void 0;
+const https = require("node:https");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const util_1 = require("../../util");
+const private_1 = require("../aws-auth/private");
+const private_2 = require("../io/private");
+class WebsiteNoticeDataSource {
+    ioHelper;
+    options;
+    constructor(ioHelper, options = {}) {
+        this.ioHelper = ioHelper;
+        this.options = options;
+    }
+    async fetch() {
+        const timeout = 3000;
+        const options = {
+            agent: await new private_1.ProxyAgentProvider(this.ioHelper).create(this.options),
+        };
+        const notices = await new Promise((resolve, reject) => {
+            let req;
+            let timer = setTimeout(() => {
+                if (req) {
+                    req.destroy(new toolkit_error_1.ToolkitError('Request timed out'));
+                }
+            }, timeout);
+            timer.unref();
+            try {
+                req = https.get('https://cli.cdk.dev-tools.aws.dev/notices.json', options, res => {
+                    if (res.statusCode === 200) {
+                        res.setEncoding('utf8');
+                        let rawData = '';
+                        res.on('data', (chunk) => {
+                            rawData += chunk;
+                        });
+                        res.on('end', () => {
+                            try {
+                                const data = JSON.parse(rawData).notices;
+                                if (!data) {
+                                    throw new toolkit_error_1.ToolkitError("'notices' key is missing from received data");
+                                }
+                                resolve(data ?? []);
+                            }
+                            catch (e) {
+                                reject(toolkit_error_1.ToolkitError.withCause(`Parse error: ${(0, util_1.formatErrorMessage)(e)}`, e));
+                            }
+                        });
+                        res.on('error', e => {
+                            reject(toolkit_error_1.ToolkitError.withCause((0, util_1.formatErrorMessage)(e), e));
+                        });
+                    }
+                    else {
+                        reject(new toolkit_error_1.ToolkitError(`${(0, util_1.humanHttpStatusError)(res.statusCode)} (Status code: ${res.statusCode})`));
+                    }
+                });
+                req.on('error', e => {
+                    reject(toolkit_error_1.ToolkitError.withCause((0, util_1.humanNetworkError)(e), e));
+                });
+            }
+            catch (e) {
+                reject(toolkit_error_1.ToolkitError.withCause((0, util_1.formatErrorMessage)(e), e));
+            }
+        });
+        await this.ioHelper.notify(private_2.IO.DEFAULT_TOOLKIT_DEBUG.msg('Notices refreshed'));
+        return notices;
+    }
+}
+exports.WebsiteNoticeDataSource = WebsiteNoticeDataSource;
+//# sourceMappingURL=data:application/json;base64,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