piclaw 0.0.19 → 0.0.21

package/.output/server/_libs/@aws-sdk/credential-provider-web-identity+[...].mjs

@@ -1,50 +0,0 @@
-import { s as __toESM } from "../../_runtime.mjs";
-import { At as init_dist_es, Ft as require_client, Nt as CredentialsProviderError, X as init_dist_es$1, Z as externalDataInterceptor } from "./client-bedrock-runtime+[...].mjs";
-import { readFileSync } from "node:fs";
-const fromWebToken = (init) => async (awsIdentityProperties) => {
-	init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
-	const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
-	let { roleAssumerWithWebIdentity } = init;
-	if (!roleAssumerWithWebIdentity) {
-		const { getDefaultRoleAssumerWithWebIdentity } = await import("../_11.mjs").then((m) => /* @__PURE__ */ __toESM(m.default));
-		roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
-			...init.clientConfig,
-			credentialProviderLogger: init.logger,
-			parentClientConfig: {
-				...awsIdentityProperties?.callerClientConfig,
-				...init.parentClientConfig
-			}
-		}, init.clientPlugins);
-	}
-	return roleAssumerWithWebIdentity({
-		RoleArn: roleArn,
-		RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
-		WebIdentityToken: webIdentityToken,
-		ProviderId: providerId,
-		PolicyArns: policyArns,
-		Policy: policy,
-		DurationSeconds: durationSeconds
-	});
-};
-var import_client = require_client();
-init_dist_es();
-init_dist_es$1();
-var ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE";
-var ENV_ROLE_ARN = "AWS_ROLE_ARN";
-var ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME";
-const fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
-	init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
-	const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
-	const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
-	const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
-	if (!webIdentityTokenFile || !roleArn) throw new CredentialsProviderError("Web identity configuration not specified", { logger: init.logger });
-	const credentials = await fromWebToken({
-		...init,
-		webIdentityToken: externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync(webIdentityTokenFile, { encoding: "ascii" }),
-		roleArn,
-		roleSessionName
-	})(awsIdentityProperties);
-	if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) (0, import_client.setCredentialFeature)(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
-	return credentials;
-};
-export { fromWebToken as n, fromTokenFile as t };

package/.output/server/_libs/@smithy/credential-provider-imds+[...].mjs

@@ -1,369 +0,0 @@
-import { n as __esmMin } from "../../_runtime.mjs";
-import { At as init_dist_es$1, B as parseUrl, D as init_dist_es$2, Nt as CredentialsProviderError, O as loadConfig, Pt as ProviderError, z as init_dist_es$3 } from "../@aws-sdk/client-bedrock-runtime+[...].mjs";
-import { request } from "http";
-import { Buffer } from "buffer";
-import { parse } from "url";
-function httpRequest(options) {
-	return new Promise((resolve, reject) => {
-		const req = request({
-			method: "GET",
-			...options,
-			hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
-		});
-		req.on("error", (err) => {
-			reject(Object.assign(new ProviderError("Unable to connect to instance metadata service"), err));
-			req.destroy();
-		});
-		req.on("timeout", () => {
-			reject(new 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 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.concat(chunks));
-				req.destroy();
-			});
-		});
-		req.end();
-	});
-}
-var init_httpRequest = __esmMin((() => {
-	init_dist_es$1();
-}));
-var isImdsCredentials, fromImdsCredentials;
-var init_ImdsCredentials = __esmMin((() => {
-	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, providerConfigFromInit;
-var init_RemoteProviderInit = __esmMin((() => {
-	DEFAULT_TIMEOUT = 1e3;
-	providerConfigFromInit = ({ maxRetries = 0, timeout = DEFAULT_TIMEOUT }) => ({
-		maxRetries,
-		timeout
-	});
-}));
-var retry;
-var init_retry = __esmMin((() => {
-	retry = (toRetry, maxRetries) => {
-		let promise = toRetry();
-		for (let i = 0; i < maxRetries; i++) promise = promise.catch(toRetry);
-		return promise;
-	};
-}));
-var ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, ENV_CMDS_AUTH_TOKEN, fromContainerMetadata, requestFromEcsImds, CMDS_IP, GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri;
-var init_fromContainerMetadata = __esmMin((() => {
-	init_dist_es$1();
-	init_httpRequest();
-	init_ImdsCredentials();
-	init_RemoteProviderInit();
-	init_retry();
-	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 CredentialsProviderError("Invalid response received from instance metadata service.", { logger: init.logger });
-			return fromImdsCredentials(credsResponse);
-		}, maxRetries);
-	};
-	requestFromEcsImds = async (timeout, options) => {
-		if (process.env["AWS_CONTAINER_AUTHORIZATION_TOKEN"]) options.headers = {
-			...options.headers,
-			Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
-		};
-		return (await httpRequest({
-			...options,
-			timeout
-		})).toString();
-	};
-	CMDS_IP = "169.254.170.2";
-	GREENGRASS_HOSTS = {
-		localhost: true,
-		"127.0.0.1": true
-	};
-	GREENGRASS_PROTOCOLS = {
-		"http:": true,
-		"https:": true
-	};
-	getCmdsUri = async ({ logger }) => {
-		if (process.env["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"]) return {
-			hostname: CMDS_IP,
-			path: process.env[ENV_CMDS_RELATIVE_URI]
-		};
-		if (process.env["AWS_CONTAINER_CREDENTIALS_FULL_URI"]) {
-			const parsed = parse(process.env[ENV_CMDS_FULL_URI]);
-			if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) throw new CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
-				tryNextLink: false,
-				logger
-			});
-			if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) throw new CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
-				tryNextLink: false,
-				logger
-			});
-			return {
-				...parsed,
-				port: parsed.port ? parseInt(parsed.port, 10) : void 0
-			};
-		}
-		throw new 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
-		});
-	};
-}));
-var InstanceMetadataV1FallbackError;
-var init_InstanceMetadataV1FallbackError = __esmMin((() => {
-	init_dist_es$1();
-	InstanceMetadataV1FallbackError = class InstanceMetadataV1FallbackError extends CredentialsProviderError {
-		tryNextLink;
-		name = "InstanceMetadataV1FallbackError";
-		constructor(message, tryNextLink = true) {
-			super(message, tryNextLink);
-			this.tryNextLink = tryNextLink;
-			Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype);
-		}
-	};
-}));
-var Endpoint;
-var init_Endpoint = __esmMin((() => {
-	(function(Endpoint) {
-		Endpoint["IPv4"] = "http://169.254.169.254";
-		Endpoint["IPv6"] = "http://[fd00:ec2::254]";
-	})(Endpoint || (Endpoint = {}));
-}));
-var ENV_ENDPOINT_NAME, CONFIG_ENDPOINT_NAME, ENDPOINT_CONFIG_OPTIONS;
-var init_EndpointConfigOptions = __esmMin((() => {
-	ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT";
-	CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint";
-	ENDPOINT_CONFIG_OPTIONS = {
-		environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME],
-		configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
-		default: void 0
-	};
-}));
-var EndpointMode;
-var init_EndpointMode = __esmMin((() => {
-	(function(EndpointMode) {
-		EndpointMode["IPv4"] = "IPv4";
-		EndpointMode["IPv6"] = "IPv6";
-	})(EndpointMode || (EndpointMode = {}));
-}));
-var ENV_ENDPOINT_MODE_NAME, CONFIG_ENDPOINT_MODE_NAME, ENDPOINT_MODE_CONFIG_OPTIONS;
-var init_EndpointModeConfigOptions = __esmMin((() => {
-	init_EndpointMode();
-	ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE";
-	CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode";
-	ENDPOINT_MODE_CONFIG_OPTIONS = {
-		environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME],
-		configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
-		default: EndpointMode.IPv4
-	};
-}));
-var getInstanceMetadataEndpoint, getFromEndpointConfig, getFromEndpointModeConfig;
-var init_getInstanceMetadataEndpoint = __esmMin((() => {
-	init_dist_es$2();
-	init_dist_es$3();
-	init_Endpoint();
-	init_EndpointConfigOptions();
-	init_EndpointMode();
-	init_EndpointModeConfigOptions();
-	getInstanceMetadataEndpoint = async () => parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig());
-	getFromEndpointConfig = async () => loadConfig(ENDPOINT_CONFIG_OPTIONS)();
-	getFromEndpointModeConfig = async () => {
-		const endpointMode = await 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)}`);
-		}
-	};
-}));
-var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, getExtendedInstanceMetadataCredentials;
-var init_getExtendedInstanceMetadataCredentials = __esmMin((() => {
-	STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 300;
-	STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 300;
-	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 * 1e3);
-		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)}.\nFor more information, please visit: https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html`);
-		const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
-		return {
-			...credentials,
-			...originalExpiration ? { originalExpiration } : {},
-			expiration: newExpiration
-		};
-	};
-}));
-var staticStabilityProvider;
-var init_staticStabilityProvider = __esmMin((() => {
-	init_getExtendedInstanceMetadataCredentials();
-	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;
-		};
-	};
-}));
-var IMDS_PATH, IMDS_TOKEN_PATH, AWS_EC2_METADATA_V1_DISABLED, PROFILE_AWS_EC2_METADATA_V1_DISABLED, X_AWS_EC2_METADATA_TOKEN, fromInstanceMetadata, getInstanceMetadataProvider, getMetadataToken, getProfile, getCredentialsFromProfile;
-var init_fromInstanceMetadata = __esmMin((() => {
-	init_dist_es$2();
-	init_dist_es$1();
-	init_InstanceMetadataV1FallbackError();
-	init_httpRequest();
-	init_ImdsCredentials();
-	init_RemoteProviderInit();
-	init_retry();
-	init_getInstanceMetadataEndpoint();
-	init_staticStabilityProvider();
-	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 (maxRetries, options) => {
-			if (disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null) {
-				let fallbackBlockedFromProfile = false;
-				let fallbackBlockedFromProcessEnv = false;
-				const configValue = await loadConfig({
-					environmentVariableSelector: (env) => {
-						const envValue = env[AWS_EC2_METADATA_V1_DISABLED];
-						fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
-						if (envValue === void 0) throw new CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });
-						return fallbackBlockedFromProcessEnv;
-					},
-					configFileSelector: (profile) => {
-						const profileValue = profile[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 profile;
-				try {
-					profile = await getProfile(options);
-				} catch (err) {
-					if (err.statusCode === 401) disableFetchToken = false;
-					throw err;
-				}
-				return profile;
-			}, maxRetries)).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;
-			}, maxRetries);
-		};
-		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 CredentialsProviderError("Invalid response received from instance metadata service.", { logger: init.logger });
-		return fromImdsCredentials(credentialsResponse);
-	};
-}));
-var init_types = __esmMin((() => {}));
-var init_dist_es = __esmMin((() => {
-	init_fromContainerMetadata();
-	init_fromInstanceMetadata();
-	init_RemoteProviderInit();
-	init_types();
-	init_httpRequest();
-	init_getInstanceMetadataEndpoint();
-}));
-export { ENV_CMDS_AUTH_TOKEN as a, fromContainerMetadata as c, httpRequest as d, Endpoint as i, DEFAULT_TIMEOUT as l, fromInstanceMetadata as n, ENV_CMDS_FULL_URI as o, getInstanceMetadataEndpoint as r, ENV_CMDS_RELATIVE_URI as s, init_dist_es as t, providerConfigFromInit as u };