@sisense/mcp-server 0.2.1

package/dist/index-d6843g0v.js

@@ -0,0 +1,372 @@
+import {
+  require_dist_cjs as require_dist_cjs2,
+  require_dist_cjs1 as require_dist_cjs3
+} from "./sse-server-nwjjjz6x.js";
+import"./sse-server-qj4zxq0f.js";
+import"./sse-server-4g9za0qq.js";
+import {
+  require_dist_cjs
+} from "./sse-server-3343e7xh.js";
+import {
+  __esm,
+  __require
+} from "./sse-server-7wcvyxyj.js";
+
+// node_modules/@smithy/credential-provider-imds/dist-cjs/index.js
+function httpRequest(options) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      method: "GET",
+      ...options,
+      hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
+    });
+    req.on("error", (err) => {
+      reject(Object.assign(new propertyProvider.ProviderError("Unable to connect to instance metadata service"), err));
+      req.destroy();
+    });
+    req.on("timeout", () => {
+      reject(new propertyProvider.ProviderError("TimeoutError from instance metadata service"));
+      req.destroy();
+    });
+    req.on("response", (res) => {
+      const { statusCode = 400 } = res;
+      if (statusCode < 200 || 300 <= statusCode) {
+        reject(Object.assign(new propertyProvider.ProviderError("Error response received from instance metadata service"), { statusCode }));
+        req.destroy();
+      }
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        resolve(buffer.Buffer.concat(chunks));
+        req.destroy();
+      });
+    });
+    req.end();
+  });
+}
+var propertyProvider, url, buffer, http, nodeConfigProvider, urlParser, isImdsCredentials = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.AccessKeyId === "string" && typeof arg.SecretAccessKey === "string" && typeof arg.Token === "string" && typeof arg.Expiration === "string", fromImdsCredentials = (creds) => ({
+  accessKeyId: creds.AccessKeyId,
+  secretAccessKey: creds.SecretAccessKey,
+  sessionToken: creds.Token,
+  expiration: new Date(creds.Expiration),
+  ...creds.AccountId && { accountId: creds.AccountId }
+}), DEFAULT_TIMEOUT = 1000, DEFAULT_MAX_RETRIES = 0, providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT }) => ({ maxRetries, timeout }), retry = (toRetry, maxRetries) => {
+  let promise = toRetry();
+  for (let i = 0;i < maxRetries; i++) {
+    promise = promise.catch(toRetry);
+  }
+  return promise;
+}, ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromContainerMetadata = (init = {}) => {
+  const { timeout, maxRetries } = providerConfigFromInit(init);
+  return () => retry(async () => {
+    const requestOptions = await getCmdsUri({ logger: init.logger });
+    const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions));
+    if (!isImdsCredentials(credsResponse)) {
+      throw new propertyProvider.CredentialsProviderError("Invalid response received from instance metadata service.", {
+        logger: init.logger
+      });
+    }
+    return fromImdsCredentials(credsResponse);
+  }, maxRetries);
+}, requestFromEcsImds = async (timeout, options) => {
+  if (process.env[ENV_CMDS_AUTH_TOKEN]) {
+    options.headers = {
+      ...options.headers,
+      Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
+    };
+  }
+  const buffer2 = await httpRequest({
+    ...options,
+    timeout
+  });
+  return buffer2.toString();
+}, CMDS_IP = "169.254.170.2", GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri = async ({ logger }) => {
+  if (process.env[ENV_CMDS_RELATIVE_URI]) {
+    return {
+      hostname: CMDS_IP,
+      path: process.env[ENV_CMDS_RELATIVE_URI]
+    };
+  }
+  if (process.env[ENV_CMDS_FULL_URI]) {
+    const parsed = url.parse(process.env[ENV_CMDS_FULL_URI]);
+    if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
+      throw new propertyProvider.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
+        tryNextLink: false,
+        logger
+      });
+    }
+    if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
+      throw new propertyProvider.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
+        tryNextLink: false,
+        logger
+      });
+    }
+    return {
+      ...parsed,
+      port: parsed.port ? parseInt(parsed.port, 10) : undefined
+    };
+  }
+  throw new propertyProvider.CredentialsProviderError("The container metadata credential provider cannot be used unless" + ` the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment` + " variable is set", {
+    tryNextLink: false,
+    logger
+  });
+}, InstanceMetadataV1FallbackError, $Endpoint = undefined, ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT", CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint", ENDPOINT_CONFIG_OPTIONS, EndpointMode, ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE", CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode", ENDPOINT_MODE_CONFIG_OPTIONS, getInstanceMetadataEndpoint = async () => urlParser.parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig()), getFromEndpointConfig = async () => nodeConfigProvider.loadConfig(ENDPOINT_CONFIG_OPTIONS)(), getFromEndpointModeConfig = async () => {
+  const endpointMode = await nodeConfigProvider.loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)();
+  switch (endpointMode) {
+    case EndpointMode.IPv4:
+      return $Endpoint.IPv4;
+    case EndpointMode.IPv6:
+      return $Endpoint.IPv6;
+    default:
+      throw new Error(`Unsupported endpoint mode: ${endpointMode}.` + ` Select from ${Object.values(EndpointMode)}`);
+  }
+}, STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html", getExtendedInstanceMetadataCredentials = (credentials, logger) => {
+  const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
+  const newExpiration = new Date(Date.now() + refreshInterval * 1000);
+  logger.warn("Attempting credential expiration extension due to a credential service availability issue. A refresh of these " + `credentials will be attempted after ${new Date(newExpiration)}.
+For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
+  const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
+  return {
+    ...credentials,
+    ...originalExpiration ? { originalExpiration } : {},
+    expiration: newExpiration
+  };
+}, staticStabilityProvider = (provider, options = {}) => {
+  const logger = options?.logger || console;
+  let pastCredentials;
+  return async () => {
+    let credentials;
+    try {
+      credentials = await provider();
+      if (credentials.expiration && credentials.expiration.getTime() < Date.now()) {
+        credentials = getExtendedInstanceMetadataCredentials(credentials, logger);
+      }
+    } catch (e) {
+      if (pastCredentials) {
+        logger.warn("Credential renew failed: ", e);
+        credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger);
+      } else {
+        throw e;
+      }
+    }
+    pastCredentials = credentials;
+    return credentials;
+  };
+}, IMDS_PATH = "/latest/meta-data/iam/security-credentials/", IMDS_TOKEN_PATH = "/latest/api/token", AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED", PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled", X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token", fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }), getInstanceMetadataProvider = (init = {}) => {
+  let disableFetchToken = false;
+  const { logger, profile } = init;
+  const { timeout, maxRetries } = providerConfigFromInit(init);
+  const getCredentials = async (maxRetries2, options) => {
+    const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
+    if (isImdsV1Fallback) {
+      let fallbackBlockedFromProfile = false;
+      let fallbackBlockedFromProcessEnv = false;
+      const configValue = await nodeConfigProvider.loadConfig({
+        environmentVariableSelector: (env) => {
+          const envValue = env[AWS_EC2_METADATA_V1_DISABLED];
+          fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
+          if (envValue === undefined) {
+            throw new propertyProvider.CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });
+          }
+          return fallbackBlockedFromProcessEnv;
+        },
+        configFileSelector: (profile2) => {
+          const profileValue = profile2[PROFILE_AWS_EC2_METADATA_V1_DISABLED];
+          fallbackBlockedFromProfile = !!profileValue && profileValue !== "false";
+          return fallbackBlockedFromProfile;
+        },
+        default: false
+      }, {
+        profile
+      })();
+      if (init.ec2MetadataV1Disabled || configValue) {
+        const causes = [];
+        if (init.ec2MetadataV1Disabled)
+          causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
+        if (fallbackBlockedFromProfile)
+          causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);
+        if (fallbackBlockedFromProcessEnv)
+          causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);
+        throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`);
+      }
+    }
+    const imdsProfile = (await retry(async () => {
+      let profile2;
+      try {
+        profile2 = await getProfile(options);
+      } catch (err) {
+        if (err.statusCode === 401) {
+          disableFetchToken = false;
+        }
+        throw err;
+      }
+      return profile2;
+    }, maxRetries2)).trim();
+    return retry(async () => {
+      let creds;
+      try {
+        creds = await getCredentialsFromProfile(imdsProfile, options, init);
+      } catch (err) {
+        if (err.statusCode === 401) {
+          disableFetchToken = false;
+        }
+        throw err;
+      }
+      return creds;
+    }, maxRetries2);
+  };
+  return async () => {
+    const endpoint = await getInstanceMetadataEndpoint();
+    if (disableFetchToken) {
+      logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
+      return getCredentials(maxRetries, { ...endpoint, timeout });
+    } else {
+      let token;
+      try {
+        token = (await getMetadataToken({ ...endpoint, timeout })).toString();
+      } catch (error) {
+        if (error?.statusCode === 400) {
+          throw Object.assign(error, {
+            message: "EC2 Metadata token request returned error"
+          });
+        } else if (error.message === "TimeoutError" || [403, 404, 405].includes(error.statusCode)) {
+          disableFetchToken = true;
+        }
+        logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
+        return getCredentials(maxRetries, { ...endpoint, timeout });
+      }
+      return getCredentials(maxRetries, {
+        ...endpoint,
+        headers: {
+          [X_AWS_EC2_METADATA_TOKEN]: token
+        },
+        timeout
+      });
+    }
+  };
+}, getMetadataToken = async (options) => httpRequest({
+  ...options,
+  path: IMDS_TOKEN_PATH,
+  method: "PUT",
+  headers: {
+    "x-aws-ec2-metadata-token-ttl-seconds": "21600"
+  }
+}), getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString(), getCredentialsFromProfile = async (profile, options, init) => {
+  const credentialsResponse = JSON.parse((await httpRequest({
+    ...options,
+    path: IMDS_PATH + profile
+  })).toString());
+  if (!isImdsCredentials(credentialsResponse)) {
+    throw new propertyProvider.CredentialsProviderError("Invalid response received from instance metadata service.", {
+      logger: init.logger
+    });
+  }
+  return fromImdsCredentials(credentialsResponse);
+}, $DEFAULT_MAX_RETRIES, $DEFAULT_TIMEOUT, $ENV_CMDS_AUTH_TOKEN, $ENV_CMDS_FULL_URI, $ENV_CMDS_RELATIVE_URI, $fromContainerMetadata, $fromInstanceMetadata, $getInstanceMetadataEndpoint, $httpRequest, $providerConfigFromInit;
+var init_dist_cjs = __esm(() => {
+  propertyProvider = require_dist_cjs();
+  url = __require("url");
+  buffer = __require("buffer");
+  http = __require("http");
+  nodeConfigProvider = require_dist_cjs3();
+  urlParser = require_dist_cjs2();
+  GREENGRASS_HOSTS = {
+    localhost: true,
+    "127.0.0.1": true
+  };
+  GREENGRASS_PROTOCOLS = {
+    "http:": true,
+    "https:": true
+  };
+  InstanceMetadataV1FallbackError = class InstanceMetadataV1FallbackError extends propertyProvider.CredentialsProviderError {
+    tryNextLink;
+    name = "InstanceMetadataV1FallbackError";
+    constructor(message, tryNextLink = true) {
+      super(message, tryNextLink);
+      this.tryNextLink = tryNextLink;
+      Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype);
+    }
+  };
+  (function(Endpoint) {
+    Endpoint["IPv4"] = "http://169.254.169.254";
+    Endpoint["IPv6"] = "http://[fd00:ec2::254]";
+  })($Endpoint || ($Endpoint = {}));
+  ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME],
+    configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
+    default: undefined
+  };
+  (function(EndpointMode2) {
+    EndpointMode2["IPv4"] = "IPv4";
+    EndpointMode2["IPv6"] = "IPv6";
+  })(EndpointMode || (EndpointMode = {}));
+  ENDPOINT_MODE_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME],
+    configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
+    default: EndpointMode.IPv4
+  };
+  STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
+  STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
+  $DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES;
+  $DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+  $ENV_CMDS_AUTH_TOKEN = ENV_CMDS_AUTH_TOKEN;
+  $ENV_CMDS_FULL_URI = ENV_CMDS_FULL_URI;
+  $ENV_CMDS_RELATIVE_URI = ENV_CMDS_RELATIVE_URI;
+  $fromContainerMetadata = fromContainerMetadata;
+  $fromInstanceMetadata = fromInstanceMetadata;
+  $getInstanceMetadataEndpoint = getInstanceMetadataEndpoint;
+  $httpRequest = httpRequest;
+  $providerConfigFromInit = providerConfigFromInit;
+});
+init_dist_cjs();
+
+export {
+  $providerConfigFromInit as providerConfigFromInit,
+  $httpRequest as httpRequest,
+  $getInstanceMetadataEndpoint as getInstanceMetadataEndpoint,
+  $fromInstanceMetadata as fromInstanceMetadata,
+  $fromContainerMetadata as fromContainerMetadata,
+  $Endpoint as Endpoint,
+  $ENV_CMDS_RELATIVE_URI as ENV_CMDS_RELATIVE_URI,
+  $ENV_CMDS_FULL_URI as ENV_CMDS_FULL_URI,
+  $ENV_CMDS_AUTH_TOKEN as ENV_CMDS_AUTH_TOKEN,
+  $DEFAULT_TIMEOUT as DEFAULT_TIMEOUT,
+  $DEFAULT_MAX_RETRIES as DEFAULT_MAX_RETRIES
+};
+export default {
+  get providerConfigFromInit() {
+    return $providerConfigFromInit;
+  },
+  get httpRequest() {
+    return $httpRequest;
+  },
+  get getInstanceMetadataEndpoint() {
+    return $getInstanceMetadataEndpoint;
+  },
+  get fromInstanceMetadata() {
+    return $fromInstanceMetadata;
+  },
+  get fromContainerMetadata() {
+    return $fromContainerMetadata;
+  },
+  get Endpoint() {
+    return $Endpoint;
+  },
+  get ENV_CMDS_RELATIVE_URI() {
+    return $ENV_CMDS_RELATIVE_URI;
+  },
+  get ENV_CMDS_FULL_URI() {
+    return $ENV_CMDS_FULL_URI;
+  },
+  get ENV_CMDS_AUTH_TOKEN() {
+    return $ENV_CMDS_AUTH_TOKEN;
+  },
+  get DEFAULT_TIMEOUT() {
+    return $DEFAULT_TIMEOUT;
+  },
+  get DEFAULT_MAX_RETRIES() {
+    return $DEFAULT_MAX_RETRIES;
+  }
+};

package/dist/index-dcrjg3fk.js

@@ -0,0 +1,207 @@
+import {
+  require_dist_cjs3 as require_dist_cjs2,
+  require_dist_cjs5 as require_dist_cjs3,
+  require_dist_cjs7 as require_dist_cjs5,
+  require_tslib
+} from "./sse-server-txz5g5t0.js";
+import {
+  require_dist_cjs
+} from "./sse-server-epd916s3.js";
+import"./sse-server-5tmgacdx.js";
+import"./sse-server-4g9za0qq.js";
+import {
+  require_client
+} from "./sse-server-mkesh468.js";
+import {
+  require_dist_cjs as require_dist_cjs4
+} from "./sse-server-3343e7xh.js";
+import {
+  __commonJS,
+  __require
+} from "./sse-server-7wcvyxyj.js";
+
+// node_modules/@aws-sdk/credential-provider-http/dist-cjs/fromHttp/checkUrl.js
+var require_checkUrl = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.checkUrl = undefined;
+  var property_provider_1 = require_dist_cjs4();
+  var ECS_CONTAINER_HOST = "169.254.170.2";
+  var EKS_CONTAINER_HOST_IPv4 = "169.254.170.23";
+  var EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]";
+  var checkUrl = (url, logger) => {
+    if (url.protocol === "https:") {
+      return;
+    }
+    if (url.hostname === ECS_CONTAINER_HOST || url.hostname === EKS_CONTAINER_HOST_IPv4 || url.hostname === EKS_CONTAINER_HOST_IPv6) {
+      return;
+    }
+    if (url.hostname.includes("[")) {
+      if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
+        return;
+      }
+    } else {
+      if (url.hostname === "localhost") {
+        return;
+      }
+      const ipComponents = url.hostname.split(".");
+      const inRange = (component) => {
+        const num = parseInt(component, 10);
+        return 0 <= num && num <= 255;
+      };
+      if (ipComponents[0] === "127" && inRange(ipComponents[1]) && inRange(ipComponents[2]) && inRange(ipComponents[3]) && ipComponents.length === 4) {
+        return;
+      }
+    }
+    throw new property_provider_1.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
+  - loopback CIDR 127.0.0.0/8 or [::1/128]
+  - ECS container host 169.254.170.2
+  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger });
+  };
+  exports.checkUrl = checkUrl;
+});
+
+// node_modules/@aws-sdk/credential-provider-http/dist-cjs/fromHttp/requestHelpers.js
+var require_requestHelpers = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createGetRequest = createGetRequest;
+  exports.getCredentials = getCredentials;
+  var property_provider_1 = require_dist_cjs4();
+  var protocol_http_1 = require_dist_cjs();
+  var smithy_client_1 = require_dist_cjs5();
+  var util_stream_1 = require_dist_cjs3();
+  function createGetRequest(url) {
+    return new protocol_http_1.HttpRequest({
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: Number(url.port),
+      path: url.pathname,
+      query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => {
+        acc[k] = v;
+        return acc;
+      }, {}),
+      fragment: url.hash
+    });
+  }
+  async function getCredentials(response, logger) {
+    const stream = (0, util_stream_1.sdkStreamMixin)(response.body);
+    const str = await stream.transformToString();
+    if (response.statusCode === 200) {
+      const parsed = JSON.parse(str);
+      if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
+        throw new property_provider_1.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " + "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger });
+      }
+      return {
+        accessKeyId: parsed.AccessKeyId,
+        secretAccessKey: parsed.SecretAccessKey,
+        sessionToken: parsed.Token,
+        expiration: (0, smithy_client_1.parseRfc3339DateTime)(parsed.Expiration)
+      };
+    }
+    if (response.statusCode >= 400 && response.statusCode < 500) {
+      let parsedBody = {};
+      try {
+        parsedBody = JSON.parse(str);
+      } catch (e) {}
+      throw Object.assign(new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }), {
+        Code: parsedBody.Code,
+        Message: parsedBody.Message
+      });
+    }
+    throw new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger });
+  }
+});
+
+// node_modules/@aws-sdk/credential-provider-http/dist-cjs/fromHttp/retry-wrapper.js
+var require_retry_wrapper = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.retryWrapper = undefined;
+  var retryWrapper = (toRetry, maxRetries, delayMs) => {
+    return async () => {
+      for (let i = 0;i < maxRetries; ++i) {
+        try {
+          return await toRetry();
+        } catch (e) {
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      }
+      return await toRetry();
+    };
+  };
+  exports.retryWrapper = retryWrapper;
+});
+
+// node_modules/@aws-sdk/credential-provider-http/dist-cjs/fromHttp/fromHttp.js
+var require_fromHttp = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromHttp = undefined;
+  var tslib_1 = require_tslib();
+  var client_1 = require_client();
+  var node_http_handler_1 = require_dist_cjs2();
+  var property_provider_1 = require_dist_cjs4();
+  var promises_1 = tslib_1.__importDefault(__require("fs/promises"));
+  var checkUrl_1 = require_checkUrl();
+  var requestHelpers_1 = require_requestHelpers();
+  var retry_wrapper_1 = require_retry_wrapper();
+  var AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
+  var DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2";
+  var AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI";
+  var AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE";
+  var AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN";
+  var fromHttp = (options = {}) => {
+    options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
+    let host;
+    const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
+    const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
+    const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
+    const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
+    const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger?.warn ? console.warn : options.logger.warn.bind(options.logger);
+    if (relative && full) {
+      warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
+      warn("awsContainerCredentialsFullUri will take precedence.");
+    }
+    if (token && tokenFile) {
+      warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
+      warn("awsContainerAuthorizationToken will take precedence.");
+    }
+    if (full) {
+      host = full;
+    } else if (relative) {
+      host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
+    } else {
+      throw new property_provider_1.CredentialsProviderError(`No HTTP credential provider host provided.
+Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger });
+    }
+    const url = new URL(host);
+    (0, checkUrl_1.checkUrl)(url, options.logger);
+    const requestHandler = node_http_handler_1.NodeHttpHandler.create({
+      requestTimeout: options.timeout ?? 1000,
+      connectionTimeout: options.timeout ?? 1000
+    });
+    return (0, retry_wrapper_1.retryWrapper)(async () => {
+      const request = (0, requestHelpers_1.createGetRequest)(url);
+      if (token) {
+        request.headers.Authorization = token;
+      } else if (tokenFile) {
+        request.headers.Authorization = (await promises_1.default.readFile(tokenFile)).toString();
+      }
+      try {
+        const result = await requestHandler.handle(request);
+        return (0, requestHelpers_1.getCredentials)(result.response).then((creds) => (0, client_1.setCredentialFeature)(creds, "CREDENTIALS_HTTP", "z"));
+      } catch (e) {
+        throw new property_provider_1.CredentialsProviderError(String(e), { logger: options.logger });
+      }
+    }, options.maxRetries ?? 3, options.timeout ?? 1000);
+  };
+  exports.fromHttp = fromHttp;
+});
+
+// node_modules/@aws-sdk/credential-provider-http/dist-cjs/index.js
+var require_dist_cjs6 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromHttp = undefined;
+  var fromHttp_1 = require_fromHttp();
+  Object.defineProperty(exports, "fromHttp", { enumerable: true, get: function() {
+    return fromHttp_1.fromHttp;
+  } });
+});
+export default require_dist_cjs6();