aws-cdk 0.0.0

package/lib/notices.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedDataSource = exports.WebsiteNoticeDataSource = exports.FilteredNotice = exports.Notices = exports.NoticesFilter = void 0;
+const https = require("node:https");
+const path = require("path");
+const fs = require("fs-extra");
+const semver = require("semver");
+const awscli_compatible_1 = require("./api/aws-auth/awscli-compatible");
+const version_1 = require("./cli/version");
+const logging_1 = require("./logging");
+const error_1 = require("./toolkit/error");
+const tree_1 = require("./tree");
+const util_1 = require("./util");
+const directories_1 = require("./util/directories");
+const error_2 = require("./util/error");
+const CACHE_FILE_PATH = path.join((0, directories_1.cdkCacheDir)(), 'notices.json');
+class NoticesFilter {
+    static filter(options) {
+        return [
+            ...this.findForCliVersion(options.data, options.cliVersion),
+            ...this.findForFrameworkVersion(options.data, options.outDir),
+            ...this.findForBootstrapVersion(options.data, options.bootstrappedEnvironments),
+        ];
+    }
+    static findForCliVersion(data, cliVersion) {
+        return (0, util_1.flatMap)(data, notice => {
+            const affectedComponent = notice.components.find(component => component.name === 'cli');
+            const affectedRange = affectedComponent === null || affectedComponent === void 0 ? void 0 : affectedComponent.version;
+            if (affectedRange == null) {
+                return [];
+            }
+            if (!semver.satisfies(cliVersion, affectedRange)) {
+                return [];
+            }
+            return [new FilteredNotice(notice)];
+        });
+    }
+    static findForFrameworkVersion(data, outDir) {
+        const tree = (0, tree_1.loadTreeFromDir)(outDir);
+        return (0, util_1.flatMap)(data, notice => {
+            //  A match happens when:
+            //
+            //  1. The version of the node matches the version in the notice, interpreted
+            //  as a semver range.
+            //
+            //  AND
+            //
+            //  2. The name in the notice is a prefix of the node name when the query ends in '.',
+            //  or the two names are exactly the same, otherwise.
+            const matched = (0, tree_1.some)(tree, node => {
+                return this.resolveAliases(notice.components).some(component => {
+                    var _a, _b;
+                    return compareNames(component.name, (_a = node.constructInfo) === null || _a === void 0 ? void 0 : _a.fqn) &&
+                        compareVersions(component.version, (_b = node.constructInfo) === null || _b === void 0 ? void 0 : _b.version);
+                });
+            });
+            if (!matched) {
+                return [];
+            }
+            return [new FilteredNotice(notice)];
+            function compareNames(pattern, target) {
+                if (target == null) {
+                    return false;
+                }
+                return pattern.endsWith('.') ? target.startsWith(pattern) : pattern === target;
+            }
+            function compareVersions(pattern, target) {
+                return semver.satisfies(target !== null && target !== void 0 ? target : '', pattern);
+            }
+        });
+    }
+    static findForBootstrapVersion(data, bootstrappedEnvironments) {
+        return (0, util_1.flatMap)(data, notice => {
+            const affectedComponent = notice.components.find(component => component.name === 'bootstrap');
+            const affectedRange = affectedComponent === null || affectedComponent === void 0 ? void 0 : affectedComponent.version;
+            if (affectedRange == null) {
+                return [];
+            }
+            const affected = bootstrappedEnvironments.filter(i => {
+                const semverBootstrapVersion = semver.coerce(i.bootstrapStackVersion);
+                if (!semverBootstrapVersion) {
+                    // we don't throw because notices should never crash the cli.
+                    (0, logging_1.warning)(`While filtering notices, could not coerce bootstrap version '${i.bootstrapStackVersion}' into semver`);
+                    return false;
+                }
+                return semver.satisfies(semverBootstrapVersion, affectedRange);
+            });
+            if (affected.length === 0) {
+                return [];
+            }
+            const filtered = new FilteredNotice(notice);
+            filtered.addDynamicValue('ENVIRONMENTS', affected.map(s => s.environment.name).join(','));
+            return [filtered];
+        });
+    }
+    static resolveAliases(components) {
+        return (0, util_1.flatMap)(components, component => {
+            if (component.name === 'framework') {
+                return [{
+                        name: '@aws-cdk/core.',
+                        version: component.version,
+                    }, {
+                        name: 'aws-cdk-lib.',
+                        version: component.version,
+                    }];
+            }
+            else {
+                return [component];
+            }
+        });
+    }
+}
+exports.NoticesFilter = NoticesFilter;
+/**
+ * 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;
+    }
+    constructor(props) {
+        var _a, _b, _c, _d, _e;
+        this.data = new Set();
+        // sets don't deduplicate interfaces, so we use a map.
+        this.bootstrappedEnvironments = new Map();
+        this.context = props.context;
+        this.acknowledgedIssueNumbers = new Set((_a = this.context.get('acknowledged-issue-numbers')) !== null && _a !== void 0 ? _a : []);
+        this.includeAcknowlegded = (_b = props.includeAcknowledged) !== null && _b !== void 0 ? _b : false;
+        this.output = (_c = props.output) !== null && _c !== void 0 ? _c : 'cdk.out';
+        this.shouldDisplay = (_d = props.shouldDisplay) !== null && _d !== void 0 ? _d : true;
+        this.httpOptions = (_e = props.httpOptions) !== null && _e !== void 0 ? _e : {};
+    }
+    /**
+     * 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.
+     * To make sure this never crashes the CLI process, all failures are caught and
+     * silently logged.
+     *
+     * If context is configured to not display notices, this will no-op.
+     */
+    async refresh(options = {}) {
+        var _a, _b;
+        if (!this.shouldDisplay) {
+            return;
+        }
+        try {
+            const underlyingDataSource = (_a = options.dataSource) !== null && _a !== void 0 ? _a : new WebsiteNoticeDataSource(this.httpOptions);
+            const dataSource = new CachedDataSource(CACHE_FILE_PATH, underlyingDataSource, (_b = options.force) !== null && _b !== void 0 ? _b : false);
+            const notices = await dataSource.fetch();
+            this.data = new Set(this.includeAcknowlegded ? notices : notices.filter(n => !this.acknowledgedIssueNumbers.has(n.issueNumber)));
+        }
+        catch (e) {
+            (0, logging_1.debug)(`Could not refresh notices: ${e}`);
+        }
+    }
+    /**
+     * Display the relevant notices (unless context dictates we shouldn't).
+     */
+    display(options = {}) {
+        var _a;
+        if (!this.shouldDisplay) {
+            return;
+        }
+        const filteredNotices = NoticesFilter.filter({
+            data: Array.from(this.data),
+            cliVersion: (0, version_1.versionNumber)(),
+            outDir: this.output,
+            bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values()),
+        });
+        if (filteredNotices.length > 0) {
+            (0, logging_1.info)('');
+            (0, logging_1.info)('NOTICES         (What\'s this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)');
+            (0, logging_1.info)('');
+            for (const filtered of filteredNotices) {
+                const formatted = filtered.format();
+                switch (filtered.notice.severity) {
+                    case 'warning':
+                        (0, logging_1.warning)(formatted);
+                        break;
+                    case 'error':
+                        (0, logging_1.error)(formatted);
+                        break;
+                    default:
+                        (0, logging_1.info)(formatted);
+                }
+                (0, logging_1.info)('');
+            }
+            (0, logging_1.info)(`If you don’t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
+        }
+        if ((_a = options.showTotal) !== null && _a !== void 0 ? _a : false) {
+            (0, logging_1.info)('');
+            (0, logging_1.info)(`There are ${filteredNotices.length} unacknowledged notice(s).`);
+        }
+    }
+}
+exports.Notices = Notices;
+/**
+ * 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 {
+    constructor(notice) {
+        this.notice = notice;
+        this.dynamicValues = {};
+    }
+    addDynamicValue(key, value) {
+        this.dynamicValues[`{resolve:${key}}`] = value;
+    }
+    format() {
+        const componentsValue = this.notice.components.map(c => `${c.name}: ${c.version}`).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) => { var _a; return (_a = this.dynamicValues[matched]) !== null && _a !== void 0 ? _a : matched; });
+    }
+}
+exports.FilteredNotice = FilteredNotice;
+class WebsiteNoticeDataSource {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch() {
+        const timeout = 3000;
+        return new Promise((resolve, reject) => {
+            let req;
+            let timer = setTimeout(() => {
+                if (req) {
+                    req.destroy(new error_1.ToolkitError('Request timed out'));
+                }
+            }, timeout);
+            timer.unref();
+            const options = {
+                agent: awscli_compatible_1.AwsCliCompatible.proxyAgent(this.options),
+            };
+            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 error_1.ToolkitError("'notices' key is missing");
+                                }
+                                (0, logging_1.debug)('Notices refreshed');
+                                resolve(data !== null && data !== void 0 ? data : []);
+                            }
+                            catch (e) {
+                                reject(new error_1.ToolkitError(`Failed to parse notices: ${(0, error_2.formatErrorMessage)(e)}`));
+                            }
+                        });
+                        res.on('error', e => {
+                            reject(new error_1.ToolkitError(`Failed to fetch notices: ${(0, error_2.formatErrorMessage)(e)}`));
+                        });
+                    }
+                    else {
+                        reject(new error_1.ToolkitError(`Failed to fetch notices. Status code: ${res.statusCode}`));
+                    }
+                });
+                req.on('error', reject);
+            }
+            catch (e) {
+                reject(new error_1.ToolkitError(`HTTPS 'get' call threw an error: ${(0, error_2.formatErrorMessage)(e)}`));
+            }
+        });
+    }
+}
+exports.WebsiteNoticeDataSource = WebsiteNoticeDataSource;
+const TIME_TO_LIVE_SUCCESS = 60 * 60 * 1000; // 1 hour
+const TIME_TO_LIVE_ERROR = 1 * 60 * 1000; // 1 minute
+class CachedDataSource {
+    constructor(fileName, dataSource, skipCache) {
+        this.fileName = fileName;
+        this.dataSource = dataSource;
+        this.skipCache = skipCache;
+    }
+    async fetch() {
+        var _a;
+        const cachedData = await this.load();
+        const data = cachedData.notices;
+        const expiration = (_a = cachedData.expiration) !== null && _a !== void 0 ? _a : 0;
+        if (Date.now() > expiration || this.skipCache) {
+            const freshData = await this.fetchInner();
+            await this.save(freshData);
+            return freshData.notices;
+        }
+        else {
+            (0, logging_1.debug)(`Reading cached notices from ${this.fileName}`);
+            return data;
+        }
+    }
+    async fetchInner() {
+        try {
+            return {
+                expiration: Date.now() + TIME_TO_LIVE_SUCCESS,
+                notices: await this.dataSource.fetch(),
+            };
+        }
+        catch (e) {
+            (0, logging_1.debug)(`Could not refresh notices: ${e}`);
+            return {
+                expiration: Date.now() + TIME_TO_LIVE_ERROR,
+                notices: [],
+            };
+        }
+    }
+    async load() {
+        const defaultValue = {
+            expiration: 0,
+            notices: [],
+        };
+        try {
+            return fs.existsSync(this.fileName)
+                ? await fs.readJSON(this.fileName)
+                : defaultValue;
+        }
+        catch (e) {
+            (0, logging_1.debug)(`Failed to load notices from cache: ${e}`);
+            return defaultValue;
+        }
+    }
+    async save(cached) {
+        try {
+            await fs.writeJSON(this.fileName, cached);
+        }
+        catch (e) {
+            (0, logging_1.debug)(`Failed to store notices in the cache: ${e}`);
+        }
+    }
+}
+exports.CachedDataSource = CachedDataSource;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notices.js","sourceRoot":"","sources":["notices.ts"],"names":[],"mappings":"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","sourcesContent":["import { ClientRequest } from 'http';\nimport { RequestOptions } from 'https';\nimport * as https from 'node:https';\nimport * as path from 'path';\nimport type { Environment } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport * as semver from 'semver';\nimport { SdkHttpOptions } from './api';\nimport { AwsCliCompatible } from './api/aws-auth/awscli-compatible';\nimport type { Context } from './api/context';\nimport { versionNumber } from './cli/version';\nimport { debug, info, warning, error } from './logging';\nimport { ToolkitError } from './toolkit/error';\nimport { loadTreeFromDir, some } from './tree';\nimport { flatMap } from './util';\nimport { cdkCacheDir } from './util/directories';\nimport { formatErrorMessage } from './util/error';\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   * Include notices that have already been acknowledged.\n   *\n   * @default false\n   */\n  readonly includeAcknowledged?: boolean;\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   * Global CLI option for whether we show notices\n   *\n   * @default true\n   */\n  readonly shouldDisplay?: boolean;\n\n  /**\n   * Options for the HTTP request\n   */\n  readonly httpOptions?: SdkHttpOptions;\n}\n\nexport interface NoticesPrintOptions {\n\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\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  public static filter(options: NoticesFilterFilterOptions): FilteredNotice[] {\n    return [\n      ...this.findForCliVersion(options.data, options.cliVersion),\n      ...this.findForFrameworkVersion(options.data, options.outDir),\n      ...this.findForBootstrapVersion(options.data, options.bootstrappedEnvironments),\n    ];\n  }\n\n  private static findForCliVersion(data: Notice[], cliVersion: string): FilteredNotice[] {\n    return flatMap(data, notice => {\n      const affectedComponent = notice.components.find(component => component.name === 'cli');\n      const affectedRange = affectedComponent?.version;\n\n      if (affectedRange == null) {\n        return [];\n      }\n\n      if (!semver.satisfies(cliVersion, affectedRange)) {\n        return [];\n      }\n\n      return [new FilteredNotice(notice)];\n    });\n\n  }\n\n  private static findForFrameworkVersion(data: Notice[], outDir: string): FilteredNotice[] {\n    const tree = loadTreeFromDir(outDir);\n    return flatMap(data, notice => {\n\n      //  A match happens when:\n      //\n      //  1. The version of the node matches the version in the notice, interpreted\n      //  as a semver range.\n      //\n      //  AND\n      //\n      //  2. The name in the notice is a prefix of the node name when the query ends in '.',\n      //  or the two names are exactly the same, otherwise.\n\n      const matched = some(tree, node => {\n        return this.resolveAliases(notice.components).some(component =>\n          compareNames(component.name, node.constructInfo?.fqn) &&\n          compareVersions(component.version, node.constructInfo?.version));\n      });\n\n      if (!matched) {\n        return [];\n      }\n\n      return [new FilteredNotice(notice)];\n\n      function compareNames(pattern: string, target: string | undefined): boolean {\n        if (target == null) { return false; }\n        return pattern.endsWith('.') ? target.startsWith(pattern) : pattern === target;\n      }\n\n      function compareVersions(pattern: string, target: string | undefined): boolean {\n        return semver.satisfies(target ?? '', pattern);\n      }\n    });\n  }\n\n  private static findForBootstrapVersion(data: Notice[], bootstrappedEnvironments: BootstrappedEnvironment[]): FilteredNotice[] {\n    return flatMap(data, notice => {\n      const affectedComponent = notice.components.find(component => component.name === 'bootstrap');\n      const affectedRange = affectedComponent?.version;\n\n      if (affectedRange == null) {\n        return [];\n      }\n\n      const affected = bootstrappedEnvironments.filter(i => {\n\n        const semverBootstrapVersion = semver.coerce(i.bootstrapStackVersion);\n        if (!semverBootstrapVersion) {\n          // we don't throw because notices should never crash the cli.\n          warning(`While filtering notices, could not coerce bootstrap version '${i.bootstrapStackVersion}' into semver`);\n          return false;\n        }\n\n        return semver.satisfies(semverBootstrapVersion, affectedRange);\n\n      });\n\n      if (affected.length === 0) {\n        return [];\n      }\n\n      const filtered = new FilteredNotice(notice);\n      filtered.addDynamicValue('ENVIRONMENTS', affected.map(s => s.environment.name).join(','));\n\n      return [filtered];\n    });\n  }\n\n  private static resolveAliases(components: Component[]): Component[] {\n    return flatMap(components, component => {\n      if (component.name === 'framework') {\n        return [{\n          name: '@aws-cdk/core.',\n          version: component.version,\n        }, {\n          name: 'aws-cdk-lib.',\n          version: component.version,\n        }];\n      } else {\n        return [component];\n      }\n    });\n  }\n}\n\n/**\n * Information about a bootstrapped environment.\n */\nexport interface BootstrappedEnvironment {\n  readonly bootstrapStackVersion: number;\n  readonly environment: Environment;\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 shouldDisplay: boolean;\n  private readonly acknowledgedIssueNumbers: Set<Number>;\n  private readonly includeAcknowlegded: boolean;\n  private readonly httpOptions: SdkHttpOptions;\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.includeAcknowlegded = props.includeAcknowledged ?? false;\n    this.output = props.output ?? 'cdk.out';\n    this.shouldDisplay = props.shouldDisplay ?? true;\n    this.httpOptions = props.httpOptions ?? {};\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   * To make sure this never crashes the CLI process, all failures are caught and\n   * silently logged.\n   *\n   * If context is configured to not display notices, this will no-op.\n   */\n  public async refresh(options: NoticesRefreshOptions = {}) {\n    if (!this.shouldDisplay) {\n      return;\n    }\n\n    try {\n      const underlyingDataSource = options.dataSource ?? new WebsiteNoticeDataSource(this.httpOptions);\n      const dataSource = new CachedDataSource(CACHE_FILE_PATH, underlyingDataSource, options.force ?? false);\n      const notices = await dataSource.fetch();\n      this.data = new Set(this.includeAcknowlegded ? notices : notices.filter(n => !this.acknowledgedIssueNumbers.has(n.issueNumber)));\n    } catch (e: any) {\n      debug(`Could not refresh notices: ${e}`);\n    }\n  }\n\n  /**\n   * Display the relevant notices (unless context dictates we shouldn't).\n   */\n  public display(options: NoticesPrintOptions = {}) {\n    if (!this.shouldDisplay) {\n      return;\n    }\n\n    const filteredNotices = NoticesFilter.filter({\n      data: Array.from(this.data),\n      cliVersion: versionNumber(),\n      outDir: this.output,\n      bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values()),\n    });\n\n    if (filteredNotices.length > 0) {\n      info('');\n      info('NOTICES         (What\\'s this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)');\n      info('');\n      for (const filtered of filteredNotices) {\n        const formatted = filtered.format();\n        switch (filtered.notice.severity) {\n          case 'warning':\n            warning(formatted);\n            break;\n          case 'error':\n            error(formatted);\n            break;\n          default:\n            info(formatted);\n        }\n        info('');\n      }\n      info(`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    if (options.showTotal ?? false) {\n      info('');\n      info(`There are ${filteredNotices.length} unacknowledged notice(s).`);\n    }\n  }\n}\n\nexport interface Component {\n  name: string;\n  version: string;\n}\n\nexport interface Notice {\n  title: string;\n  issueNumber: number;\n  overview: string;\n  components: Component[];\n  schemaVersion: string;\n  severity?: string;\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  public addDynamicValue(key: string, value: string) {\n    this.dynamicValues[`{resolve:${key}}`] = value;\n  }\n\n  public format(): string {\n\n    const componentsValue = this.notice.components.map(c => `${c.name}: ${c.version}`).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\nexport interface NoticeDataSource {\n  fetch(): Promise<Notice[]>;\n}\n\nexport class WebsiteNoticeDataSource implements NoticeDataSource {\n  private readonly options: SdkHttpOptions;\n\n  constructor(options: SdkHttpOptions = {}) {\n    this.options = options;\n  }\n\n  fetch(): Promise<Notice[]> {\n    const timeout = 3000;\n    return new Promise((resolve, reject) => {\n      let req: ClientRequest | undefined;\n\n      let timer = setTimeout(() => {\n        if (req) {\n          req.destroy(new ToolkitError('Request timed out'));\n        }\n      }, timeout);\n\n      timer.unref();\n\n      const options: RequestOptions = {\n        agent: AwsCliCompatible.proxyAgent(this.options),\n      };\n\n      try {\n        req = https.get('https://cli.cdk.dev-tools.aws.dev/notices.json',\n          options,\n          res => {\n            if (res.statusCode === 200) {\n              res.setEncoding('utf8');\n              let rawData = '';\n              res.on('data', (chunk) => {\n                rawData += chunk;\n              });\n              res.on('end', () => {\n                try {\n                  const data = JSON.parse(rawData).notices as Notice[];\n                  if (!data) {\n                    throw new ToolkitError(\"'notices' key is missing\");\n                  }\n                  debug('Notices refreshed');\n                  resolve(data ?? []);\n                } catch (e: any) {\n                  reject(new ToolkitError(`Failed to parse notices: ${formatErrorMessage(e)}`));\n                }\n              });\n              res.on('error', e => {\n                reject(new ToolkitError(`Failed to fetch notices: ${formatErrorMessage(e)}`));\n              });\n            } else {\n              reject(new ToolkitError(`Failed to fetch notices. Status code: ${res.statusCode}`));\n            }\n          });\n        req.on('error', reject);\n      } catch (e: any) {\n        reject(new ToolkitError(`HTTPS 'get' call threw an error: ${formatErrorMessage(e)}`));\n      }\n    });\n  }\n}\n\ninterface CachedNotices {\n  expiration: number;\n  notices: Notice[];\n}\n\nconst TIME_TO_LIVE_SUCCESS = 60 * 60 * 1000; // 1 hour\nconst TIME_TO_LIVE_ERROR = 1 * 60 * 1000; // 1 minute\n\nexport class CachedDataSource implements NoticeDataSource {\n  constructor(\n    private readonly fileName: string,\n    private readonly dataSource: NoticeDataSource,\n    private readonly skipCache?: boolean) {\n  }\n\n  async fetch(): Promise<Notice[]> {\n    const cachedData = await this.load();\n    const data = cachedData.notices;\n    const expiration = cachedData.expiration ?? 0;\n\n    if (Date.now() > expiration || this.skipCache) {\n      const freshData = await this.fetchInner();\n      await this.save(freshData);\n      return freshData.notices;\n    } else {\n      debug(`Reading cached notices from ${this.fileName}`);\n      return data;\n    }\n  }\n\n  private async fetchInner(): Promise<CachedNotices> {\n    try {\n      return {\n        expiration: Date.now() + TIME_TO_LIVE_SUCCESS,\n        notices: await this.dataSource.fetch(),\n      };\n    } catch (e) {\n      debug(`Could not refresh notices: ${e}`);\n      return {\n        expiration: Date.now() + TIME_TO_LIVE_ERROR,\n        notices: [],\n      };\n    }\n  }\n\n  private async load(): Promise<CachedNotices> {\n    const defaultValue = {\n      expiration: 0,\n      notices: [],\n    };\n\n    try {\n      return fs.existsSync(this.fileName)\n        ? await fs.readJSON(this.fileName) as CachedNotices\n        : defaultValue;\n    } catch (e) {\n      debug(`Failed to load notices from cache: ${e}`);\n      return defaultValue;\n    }\n  }\n\n  private async save(cached: CachedNotices): Promise<void> {\n    try {\n      await fs.writeJSON(this.fileName, cached);\n    } catch (e) {\n      debug(`Failed to store notices in the cache: ${e}`);\n    }\n  }\n}\n"]}

package/lib/os.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OS helpers
+ *
+ * Shell function which both prints to stdout and collects the output into a
+ * string.
+ */
+export declare function shell(command: string[]): Promise<string>;

package/lib/os.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shell = shell;
+const child_process = require("child_process");
+const chalk = require("chalk");
+const logging_1 = require("./logging");
+const error_1 = require("./toolkit/error");
+/**
+ * OS helpers
+ *
+ * Shell function which both prints to stdout and collects the output into a
+ * string.
+ */
+async function shell(command) {
+    const commandLine = renderCommandLine(command);
+    (0, logging_1.debug)(`Executing ${chalk.blue(commandLine)}`);
+    const child = child_process.spawn(command[0], renderArguments(command.slice(1)), {
+        // Need this for Windows where we want .cmd and .bat to be found as well.
+        shell: true,
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    return new Promise((resolve, reject) => {
+        const stdout = new Array();
+        // Both write to stdout and collect
+        child.stdout.on('data', chunk => {
+            process.stdout.write(chunk);
+            stdout.push(chunk);
+        });
+        child.once('error', reject);
+        child.once('exit', code => {
+            if (code === 0) {
+                resolve(Buffer.from(stdout).toString('utf-8'));
+            }
+            else {
+                reject(new error_1.ToolkitError(`${commandLine} exited with error code ${code}`));
+            }
+        });
+    });
+}
+function renderCommandLine(cmd) {
+    return renderArguments(cmd).join(' ');
+}
+/**
+ * Render the arguments to include escape characters for each platform.
+ */
+function renderArguments(cmd) {
+    if (process.platform !== 'win32') {
+        return doRender(cmd, hasAnyChars(' ', '\\', '!', '"', "'", '&', '$'), posixEscape);
+    }
+    else {
+        return doRender(cmd, hasAnyChars(' ', '"', '&', '^', '%'), windowsEscape);
+    }
+}
+/**
+ * Render a UNIX command line
+ */
+function doRender(cmd, needsEscaping, doEscape) {
+    return cmd.map(x => needsEscaping(x) ? doEscape(x) : x);
+}
+/**
+ * Return a predicate that checks if a string has any of the indicated chars in it
+ */
+function hasAnyChars(...chars) {
+    return (str) => {
+        return chars.some(c => str.indexOf(c) !== -1);
+    };
+}
+/**
+ * Escape a shell argument for POSIX shells
+ *
+ * Wrapping in single quotes and escaping single quotes inside will do it for us.
+ */
+function posixEscape(x) {
+    // Turn ' -> '"'"'
+    x = x.replace(/'/g, "'\"'\"'");
+    return `'${x}'`;
+}
+/**
+ * Escape a shell argument for cmd.exe
+ *
+ * This is how to do it right, but I'm not following everything:
+ *
+ * https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+ */
+function windowsEscape(x) {
+    // First surround by double quotes, ignore the part about backslashes
+    x = `"${x}"`;
+    // Now escape all special characters
+    const shellMeta = new Set(['"', '&', '^', '%']);
+    return x.split('').map(c => shellMeta.has(x) ? '^' + c : c).join('');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/serialize.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Stringify to YAML
+ */
+export declare function toYAML(obj: any): string;
+/**
+ * Parse either YAML or JSON
+ */
+export declare function deserializeStructure(str: string): any;
+/**
+ * Serialize to either YAML or JSON
+ */
+export declare function serializeStructure(object: any, json: boolean): string;
+/**
+ * Load a YAML or JSON file from disk
+ */
+export declare function loadStructuredFile(fileName: string): Promise<any>;
+/**
+ * Remove any template elements that we don't want to show users.
+ */
+export declare function obscureTemplate(template?: any): any;
+/**
+ * A JSON.stringify() replacer that converts Buffers into a string with information
+ * Use this if you plan to print out JSON stringified objects that may contain a Buffer.
+ * Without this, large buffers (think: Megabytes) will completely fill up the output
+ * and even crash the system.
+ */
+export declare function replacerBufferWithInfo(_key: any, value: any): any;