aws-cdk 2.1142.0 → 2.1144.0

package/lib/cli/proxy-agent.js

@@ -35,9 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyAgentProvider = void 0;
 exports.validateProxyAddress = validateProxyAddress;
-const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+exports.normalizeNetworkSetting = normalizeNetworkSetting;
+const path = __importStar(require("node:path"));
 const fs = __importStar(require("fs-extra"));
 const proxy_agent_1 = require("proxy-agent");
+const api_private_error_1 = require("../api-private-error");
 /**
  * Validate a proxy address up front.
  *
@@ -52,51 +54,87 @@ function validateProxyAddress(proxyAddress) {
         protocol = new URL(proxyAddress).protocol.replace(/:$/, '');
     }
     catch {
-        throw new toolkit_lib_1.ToolkitError('InvalidProxyAddress', `Invalid proxy address '${proxyAddress}': it must be a URL that includes a protocol, e.g. 'http://${proxyAddress}'.`);
+        throw new api_private_error_1.ToolkitError('InvalidProxyAddress', `Invalid proxy address '${proxyAddress}': it must be a URL that includes a protocol, e.g. 'http://${proxyAddress}'.`);
     }
     if (!(protocol in proxy_agent_1.proxies)) {
-        throw new toolkit_lib_1.ToolkitError('InvalidProxyAddress', `Unsupported protocol '${protocol}' in proxy address '${proxyAddress}'. Supported protocols are: ${Object.keys(proxy_agent_1.proxies).join(', ')}.`);
+        throw new api_private_error_1.ToolkitError('InvalidProxyAddress', `Unsupported protocol '${protocol}' in proxy address '${proxyAddress}'. Supported protocols are: ${Object.keys(proxy_agent_1.proxies).join(', ')}.`);
     }
 }
+/**
+ * Coerce a raw network setting into a value the rest of the CLI can rely on.
+ *
+ * `Settings.get()` is untyped and surfaces an unset `--proxy` or `--ca-bundle-path` as either
+ * `undefined` or an empty array, depending on how it was parsed. An empty STRING is a different
+ * thing: `--proxy ''` means "go direct, ignore the proxy environment variables", so it has to survive
+ * normalization. Anything that is not a string counts as unconfigured, which is what makes the
+ * environment the fallback.
+ *
+ * Applied at the point these settings enter typed code, for two reasons. An empty array is truthy, so
+ * it slips past every `if (value)` guard downstream and then fails somewhere unhelpful --
+ * `path.resolve([])` throws a `TypeError` that the CA-bundle resolver swallows, silently discarding
+ * the bundle. And both values now cross a process boundary into the detached telemetry sender, which
+ * has no access to the settings to re-derive them.
+ */
+function normalizeNetworkSetting(raw) {
+    return typeof raw === 'string' ? raw : undefined;
+}
 class ProxyAgentProvider {
     ioHelper;
     constructor(ioHelper) {
         this.ioHelper = ioHelper;
     }
     async create(options) {
-        // Only validate when an actual proxy address was configured. When `--proxy`
-        // is not given the setting is unset (and can surface at runtime as an empty
-        // string or empty array), in which case we skip validation and let
-        // ProxyAgent fall back to environment-variable detection.
-        if (typeof options.proxyAddress === 'string' && options.proxyAddress.length > 0) {
-            validateProxyAddress(options.proxyAddress);
+        const proxyAddress = normalizeNetworkSetting(options.proxyAddress);
+        // Only a non-empty address is a proxy to validate. An empty one is a configured "go direct".
+        if (proxyAddress) {
+            validateProxyAddress(proxyAddress);
         }
-        // Force it to use the proxy provided through the command line.
-        // Otherwise, let the ProxyAgent auto-detect the proxy using environment variables.
-        const getProxyForUrl = options.proxyAddress != null
-            ? () => Promise.resolve(options.proxyAddress)
+        // Force it to use the proxy provided through the command line -- including an empty one, which
+        // `proxy-agent` reads as "no proxy for this URL". Only an unconfigured proxy falls through to
+        // ProxyAgent's own environment-variable detection.
+        const getProxyForUrl = proxyAddress !== undefined
+            ? () => Promise.resolve(proxyAddress)
             : undefined;
-        return new proxy_agent_1.ProxyAgent({
-            ca: await this.tryGetCACert(options.caBundlePath),
-            getProxyForUrl,
-        });
+        const caBundlePath = await this.resolveCABundlePath(normalizeNetworkSetting(options.caBundlePath));
+        return {
+            agent: new proxy_agent_1.ProxyAgent({
+                ca: await this.tryReadCABundle(caBundlePath),
+                getProxyForUrl,
+            }),
+            caBundlePath,
+        };
     }
-    async tryGetCACert(bundlePath) {
-        const path = bundlePath || this.caBundlePathFromEnvironment();
-        if (path) {
-            await this.ioHelper.defaults.debug(`Using CA bundle path: ${path}`);
-            try {
-                if (!fs.pathExistsSync(path)) {
-                    return undefined;
-                }
-                return fs.readFileSync(path, { encoding: 'utf-8' });
-            }
-            catch (e) {
-                await this.ioHelper.defaults.debug(String(e));
-                return undefined;
-            }
+    /**
+     * Resolve the configured CA bundle to an absolute path, or undefined if there isn't a usable one.
+     *
+     * Absolute because the path is handed to the detached sender, which runs from a different cwd.
+     */
+    async resolveCABundlePath(bundlePath) {
+        const configured = bundlePath || this.caBundlePathFromEnvironment();
+        if (!configured) {
+            return undefined;
+        }
+        try {
+            const resolved = path.resolve(configured);
+            await this.ioHelper.defaults.debug(`Using CA bundle path: ${resolved}`);
+            return fs.pathExistsSync(resolved) ? resolved : undefined;
+        }
+        catch (e) {
+            await this.ioHelper.defaults.debug(String(e));
+            return undefined;
+        }
+    }
+    async tryReadCABundle(bundlePath) {
+        if (!bundlePath) {
+            return undefined;
+        }
+        try {
+            return fs.readFileSync(bundlePath, { encoding: 'utf-8' });
+        }
+        catch (e) {
+            await this.ioHelper.defaults.debug(String(e));
+            return undefined;
         }
-        return undefined;
     }
     /**
      * Find and return a CA certificate bundle path to be passed into the SDK.
@@ -112,4 +150,4 @@ class ProxyAgentProvider {
     }
 }
 exports.ProxyAgentProvider = ProxyAgentProvider;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy-agent.js","sourceRoot":"","sources":["proxy-agent.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport * as fs from 'fs-extra';\nimport { ProxyAgent, proxies } from 'proxy-agent';\nimport { ToolkitError } from '../api-private-error';\n\n/**\n * Validate a proxy address up front.\n *\n * `proxy-agent` only rejects an address with a missing or unsupported protocol\n * lazily, on the first request, so without `-vvv` the CLI appears to hang or\n * fails later with a misleading error (e.g. missing credentials). Fail fast\n * here with an actionable message instead.\n */\nexport function validateProxyAddress(proxyAddress: string): void {\n  let protocol: string;\n  try {\n    protocol = new URL(proxyAddress).protocol.replace(/:$/, '');\n  } catch {\n    throw new ToolkitError(\n      'InvalidProxyAddress',\n      `Invalid proxy address '${proxyAddress}': it must be a URL that includes a protocol, e.g. 'http://${proxyAddress}'.`,\n    );\n  }\n\n  if (!(protocol in proxies)) {\n    throw new ToolkitError(\n      'InvalidProxyAddress',\n      `Unsupported protocol '${protocol}' in proxy address '${proxyAddress}'. Supported protocols are: ${Object.keys(proxies).join(', ')}.`,\n    );\n  }\n}\n\n/**\n * Coerce a raw network setting into a value the rest of the CLI can rely on.\n *\n * `Settings.get()` is untyped and surfaces an unset `--proxy` or `--ca-bundle-path` as either\n * `undefined` or an empty array, depending on how it was parsed. An empty STRING is a different\n * thing: `--proxy ''` means \"go direct, ignore the proxy environment variables\", so it has to survive\n * normalization. Anything that is not a string counts as unconfigured, which is what makes the\n * environment the fallback.\n *\n * Applied at the point these settings enter typed code, for two reasons. An empty array is truthy, so\n * it slips past every `if (value)` guard downstream and then fails somewhere unhelpful --\n * `path.resolve([])` throws a `TypeError` that the CA-bundle resolver swallows, silently discarding\n * the bundle. And both values now cross a process boundary into the detached telemetry sender, which\n * has no access to the settings to re-derive them.\n */\nexport function normalizeNetworkSetting(raw: unknown): string | undefined {\n  return typeof raw === 'string' ? raw : undefined;\n}\n\n/**\n * Options for proxy-agent SDKs\n */\ninterface ProxyAgentOptions {\n  /**\n   * Proxy address to use\n   *\n   * @default No proxy\n   */\n  readonly proxyAddress?: string;\n\n  /**\n   * A path to a certificate bundle that contains a cert to be trusted.\n   *\n   * @default No certificate bundle\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * The proxy configuration resolved for this invocation.\n */\nexport interface ResolvedProxyAgent {\n  /**\n   * The agent to pass to anything making HTTPS requests in this process.\n   */\n  readonly agent: ProxyAgent;\n\n  /**\n   * Absolute path to the resolved CA bundle, if one was configured and exists on disk.\n   *\n   * Exposed because `agent` cannot cross a process boundary: the detached telemetry sender builds its\n   * own and needs to be told which bundle to trust. The path travels rather than the bytes, because a\n   * system bundle is routinely ~190KB.\n   *\n   * @default - no CA bundle was configured, or the configured one does not exist\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * The part of `IoHelper` that proxy resolution needs.\n *\n * Structural so the detached telemetry sender, which has no IoHost, can pass a writer that goes to\n * stderr instead. A full `IoHelper` satisfies this as-is.\n */\nexport interface ProxyAgentDiagnostics {\n  readonly defaults: {\n    debug(message: string): Promise<void>;\n  };\n}\n\nexport class ProxyAgentProvider {\n  private readonly ioHelper: ProxyAgentDiagnostics;\n\n  public constructor(ioHelper: ProxyAgentDiagnostics) {\n    this.ioHelper = ioHelper;\n  }\n\n  public async create(options: ProxyAgentOptions): Promise<ResolvedProxyAgent> {\n    const proxyAddress = normalizeNetworkSetting(options.proxyAddress);\n\n    // Only a non-empty address is a proxy to validate. An empty one is a configured \"go direct\".\n    if (proxyAddress) {\n      validateProxyAddress(proxyAddress);\n    }\n\n    // Force it to use the proxy provided through the command line -- including an empty one, which\n    // `proxy-agent` reads as \"no proxy for this URL\". Only an unconfigured proxy falls through to\n    // ProxyAgent's own environment-variable detection.\n    const getProxyForUrl = proxyAddress !== undefined\n      ? () => Promise.resolve(proxyAddress)\n      : undefined;\n\n    const caBundlePath = await this.resolveCABundlePath(normalizeNetworkSetting(options.caBundlePath));\n\n    return {\n      agent: new ProxyAgent({\n        ca: await this.tryReadCABundle(caBundlePath),\n        getProxyForUrl,\n      }),\n      caBundlePath,\n    };\n  }\n\n  /**\n   * Resolve the configured CA bundle to an absolute path, or undefined if there isn't a usable one.\n   *\n   * Absolute because the path is handed to the detached sender, which runs from a different cwd.\n   */\n  private async resolveCABundlePath(bundlePath?: string): Promise<string | undefined> {\n    const configured = bundlePath || this.caBundlePathFromEnvironment();\n    if (!configured) {\n      return undefined;\n    }\n\n    try {\n      const resolved = path.resolve(configured);\n      await this.ioHelper.defaults.debug(`Using CA bundle path: ${resolved}`);\n      return fs.pathExistsSync(resolved) ? resolved : undefined;\n    } catch (e: any) {\n      await this.ioHelper.defaults.debug(String(e));\n      return undefined;\n    }\n  }\n\n  private async tryReadCABundle(bundlePath?: string): Promise<string | undefined> {\n    if (!bundlePath) {\n      return undefined;\n    }\n    try {\n      return fs.readFileSync(bundlePath, { encoding: 'utf-8' });\n    } catch (e: any) {\n      await this.ioHelper.defaults.debug(String(e));\n      return undefined;\n    }\n  }\n\n  /**\n   * Find and return a CA certificate bundle path to be passed into the SDK.\n   */\n  private caBundlePathFromEnvironment(): string | undefined {\n    if (process.env.aws_ca_bundle) {\n      return process.env.aws_ca_bundle;\n    }\n    if (process.env.AWS_CA_BUNDLE) {\n      return process.env.AWS_CA_BUNDLE;\n    }\n    return undefined;\n  }\n}\n"]}

package/lib/cli/telemetry/post-telemetry.d.ts

@@ -0,0 +1,31 @@
+import type { IncomingMessage } from 'http';
+import type { Agent } from 'https';
+import type { TelemetrySchema } from './schema';
+/**
+ * A batch of telemetry events, as the endpoint expects to receive it.
+ */
+export interface TelemetryBatch {
+    readonly events: TelemetrySchema[];
+}
+/**
+ * Options for a single delivery attempt.
+ */
+export interface PostTelemetryOptions {
+    /**
+     * Agent to make the request through, carrying proxy and CA configuration.
+     *
+     * @default - Node's default agent, i.e. a direct connection
+     */
+    readonly agent?: Agent;
+    /**
+     * Abort the attempt if the request has not completed within this many milliseconds.
+     */
+    readonly timeoutMs: number;
+}
+/**
+ * POST a batch of telemetry events, resolving with the endpoint's response.
+ *
+ * Rejects if the connection fails or the timeout expires, but NOT on an unsuccessful status code --
+ * inspect `statusCode` for that.
+ */
+export declare function postTelemetry(url: URL, batch: TelemetryBatch, options: PostTelemetryOptions): Promise<IncomingMessage>;

package/lib/cli/telemetry/post-telemetry.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postTelemetry = postTelemetry;
+const https_1 = require("https");
+const tls = __importStar(require("tls"));
+const api_private_error_1 = require("../../api-private-error");
+/**
+ * POST a batch of telemetry events, resolving with the endpoint's response.
+ *
+ * Rejects if the connection fails or the timeout expires, but NOT on an unsuccessful status code --
+ * inspect `statusCode` for that.
+ */
+function postTelemetry(url, batch, options) {
+    return new Promise((ok, ko) => {
+        const payload = JSON.stringify(batch);
+        const req = (0, https_1.request)({
+            hostname: url.hostname,
+            port: url.port || null,
+            path: url.pathname + url.search,
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(payload),
+                // The only caller makes one request and exits, so a keep-alive socket left in the agent's
+                // pool would just be something else holding the process open.
+                'connection': 'close',
+            },
+            agent: options.agent,
+            timeout: options.timeoutMs,
+            // Always pin identity to the destination host. `https-proxy-agent` does the TLS upgrade itself
+            // without passing that host to `tls.connect`, so for an IP-literal endpoint Node has nothing to
+            // match against and skips the check entirely -- naming the host explicitly closes that hole and
+            // pins to the endpoint rather than to whatever the proxy presents.
+            checkServerIdentity: (_host, cert) => tls.checkServerIdentity(url.hostname, cert),
+        }, ok);
+        req.on('error', ko);
+        req.on('timeout', () => {
+            req.destroy(new api_private_error_1.ToolkitError('RequestTimeout', `Timeout after ${options.timeoutMs}ms, aborting request`));
+        });
+        req.end(payload);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/telemetry/sender-bundle.d.ts

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