Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
#!/usr/bin/env bash
# Isolate local Minikube image operations from ambient Docker credentials.
# Source this file, call docker_cli_env_prepare, and install a caller-owned EXIT
# trap that invokes docker_cli_env_cleanup.
if [[ -n "${DOCKER_CLI_ENV_LOADED:-}" ]]; then
return 0
fi
DOCKER_CLI_ENV_LOADED=true
DOCKER_CLI_ENV_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
DOCKER_CLI_DEADLINE_RUNNER="${DOCKER_CLI_ENV_DIR}/run-with-deadline.mjs"
DOCKER_CLI_TASK_CONFIG=""
DOCKER_CLI_AUTH_CONFIG=""
DOCKER_CLI_PINNED_HOST=""
DOCKER_CLI_ENDPOINT_SOURCE=""
DOCKER_CLI_ORIGINAL_CONFIG_SET="${DOCKER_CONFIG+x}"
DOCKER_CLI_ORIGINAL_CONFIG="${DOCKER_CONFIG-}"
DOCKER_CLI_ORIGINAL_AUTH_SET="${DOCKER_AUTH_CONFIG+x}"
DOCKER_CLI_ORIGINAL_AUTH="${DOCKER_AUTH_CONFIG-}"
DOCKER_CLI_ORIGINAL_CONTEXT_SET="${DOCKER_CONTEXT+x}"
DOCKER_CLI_ORIGINAL_CONTEXT="${DOCKER_CONTEXT-}"
DOCKER_CLI_ORIGINAL_HOST_SET="${DOCKER_HOST+x}"
DOCKER_CLI_ORIGINAL_HOST="${DOCKER_HOST-}"
DOCKER_CLI_ORIGINAL_TLS_SET="${DOCKER_TLS+x}"
DOCKER_CLI_ORIGINAL_TLS="${DOCKER_TLS-}"
DOCKER_CLI_ORIGINAL_TLS_VERIFY_SET="${DOCKER_TLS_VERIFY+x}"
DOCKER_CLI_ORIGINAL_TLS_VERIFY="${DOCKER_TLS_VERIFY-}"
DOCKER_CLI_ORIGINAL_CERT_PATH_SET="${DOCKER_CERT_PATH+x}"
DOCKER_CLI_ORIGINAL_CERT_PATH="${DOCKER_CERT_PATH-}"
DOCKER_CLI_ORIGINAL_API_VERSION_SET="${DOCKER_API_VERSION+x}"
DOCKER_CLI_ORIGINAL_API_VERSION="${DOCKER_API_VERSION-}"
DOCKER_CLI_ORIGINAL_CUSTOM_HEADERS_SET="${DOCKER_CUSTOM_HEADERS+x}"
DOCKER_CLI_ORIGINAL_CUSTOM_HEADERS="${DOCKER_CUSTOM_HEADERS-}"
DOCKER_CLI_ORIGINAL_MINIKUBE_ACTIVE_SET="${MINIKUBE_ACTIVE_DOCKERD+x}"
DOCKER_CLI_ORIGINAL_MINIKUBE_ACTIVE="${MINIKUBE_ACTIVE_DOCKERD-}"
MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS="${MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS:-30}"
MINIKUBE_DOCKER_PULL_TIMEOUT_SECONDS="${MINIKUBE_DOCKER_PULL_TIMEOUT_SECONDS:-600}"
MINIKUBE_DOCKER_BUILD_TIMEOUT_SECONDS="${MINIKUBE_DOCKER_BUILD_TIMEOUT_SECONDS:-1800}"
MINIKUBE_DOCKER_HEARTBEAT_SECONDS="${MINIKUBE_DOCKER_HEARTBEAT_SECONDS:-20}"
MINIKUBE_DOCKER_KILL_GRACE_SECONDS="${MINIKUBE_DOCKER_KILL_GRACE_SECONDS:-5}"
MINIKUBE_DOCKER_START_PROBE_TIMEOUT_SECONDS="${MINIKUBE_DOCKER_START_PROBE_TIMEOUT_SECONDS:-5}"
MINIKUBE_DOCKER_START_TIMEOUT_SECONDS="${MINIKUBE_DOCKER_START_TIMEOUT_SECONDS:-60}"
MINIKUBE_DOCKER_START_POLL_SECONDS="${MINIKUBE_DOCKER_START_POLL_SECONDS:-2}"
docker_cli_env_error() {
printf '%s\n' "$*" >&2
}
docker_cli_env_validate_seconds() {
local name="$1" value="$2" maximum="$3"
if ! [[ "$value" =~ ^[1-9][0-9]*$ ]] || (( value > maximum )); then
docker_cli_env_error "DOCKER_DEADLINE_INVALID: ${name} must be an integer from 1 to ${maximum}"
return 2
fi
}
docker_cli_env_validate_deadlines() {
docker_cli_env_validate_seconds MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS "$MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS" 300 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_PULL_TIMEOUT_SECONDS "$MINIKUBE_DOCKER_PULL_TIMEOUT_SECONDS" 3600 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_BUILD_TIMEOUT_SECONDS "$MINIKUBE_DOCKER_BUILD_TIMEOUT_SECONDS" 7200 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_HEARTBEAT_SECONDS "$MINIKUBE_DOCKER_HEARTBEAT_SECONDS" 300 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_KILL_GRACE_SECONDS "$MINIKUBE_DOCKER_KILL_GRACE_SECONDS" 30 || return $?
}
docker_cli_env_validate_startup_deadlines() {
docker_cli_env_validate_seconds MINIKUBE_DOCKER_START_PROBE_TIMEOUT_SECONDS \
"$MINIKUBE_DOCKER_START_PROBE_TIMEOUT_SECONDS" 60 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_START_TIMEOUT_SECONDS \
"$MINIKUBE_DOCKER_START_TIMEOUT_SECONDS" 600 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_START_POLL_SECONDS \
"$MINIKUBE_DOCKER_START_POLL_SECONDS" 30 || return $?
}
docker_cli_env_validate_local_endpoint() {
local endpoint="$1" port=""
case "$endpoint" in
unix:///*)
# Unix sockets always terminate on this machine. Require an absolute,
# single-line path so a malformed context cannot be reinterpreted by the
# Docker CLI after it is pinned into DOCKER_HOST.
[[ "$endpoint" != *$'\n'* && "$endpoint" != *$'\r'* \
&& "$endpoint" != *'?'* && "$endpoint" != *'#'* \
&& "$endpoint" != "unix:///" ]] || {
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: the resolved Unix endpoint is malformed"
return 1
}
;;
tcp://*)
if [[ "$endpoint" =~ ^tcp://(localhost|127\.0\.0\.1):([1-9][0-9]*)$ ]]; then
port="${BASH_REMATCH[2]}"
elif [[ "$endpoint" =~ ^tcp://\[::1\]:([1-9][0-9]*)$ ]]; then
port="${BASH_REMATCH[1]}"
else
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: refusing a non-loopback or malformed TCP endpoint"
return 1
fi
if ! [[ "$port" =~ ^[1-9][0-9]*$ ]] || (( port > 65535 )); then
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: the resolved loopback endpoint has an invalid port"
return 1
fi
;;
npipe:////./pipe/docker_engine)
[[ "${OS:-}" == Windows_NT ]] || {
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: a Windows named pipe is not local on this host"
return 1
}
;;
*)
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: refusing a remote or ambiguous Docker endpoint"
return 1
;;
esac
}
docker_cli_env_resolve_context_endpoint() {
local record="" status=0 context_host="" skip_tls="" tls_material=""
# Context inspection is metadata-only and happens before DOCKER_CONFIG is
# replaced. DOCKER_AUTH_CONFIG and custom headers are excluded even here so
# endpoint discovery cannot consult registry auth or carry ambient headers.
record="$({
unset DOCKER_AUTH_CONFIG DOCKER_CUSTOM_HEADERS
node "$DOCKER_CLI_DEADLINE_RUNNER" \
--timeout-seconds "$MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS" \
--heartbeat-seconds "$MINIKUBE_DOCKER_HEARTBEAT_SECONDS" \
--kill-grace-seconds "$MINIKUBE_DOCKER_KILL_GRACE_SECONDS" \
--label docker-endpoint-resolve -- \
docker context inspect \
--format '{{.Endpoints.docker.Host}}{{"\t"}}{{.Endpoints.docker.SkipTLSVerify}}{{"\t"}}{{json .TLSMaterial}}'
})" || status=$?
if [[ "$status" -ne 0 ]]; then
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: could not resolve the active Docker context"
return "$status"
fi
if [[ -z "$record" || "$record" == *$'\n'* ]]; then
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: the active Docker context did not resolve exactly one endpoint"
return 1
fi
IFS=$'\t' read -r context_host skip_tls tls_material <<<"$record"
[[ -n "$context_host" && -n "$skip_tls" && -n "$tls_material" ]] || {
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: the active Docker context metadata is incomplete"
return 1
}
case "$skip_tls" in
true|false) ;;
*)
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: the active Docker context TLS metadata is invalid"
return 1
;;
esac
docker_cli_env_validate_local_endpoint "$context_host" || return $?
if [[ "$context_host" == tcp://* ]] \
&& { [[ "$skip_tls" == true ]] || [[ "$tls_material" != '{}' && "$tls_material" != null ]]; }; then
docker_cli_env_error "DOCKER_ENDPOINT_UNSAFE: a config-only loopback TLS context cannot be isolated safely"
return 1
fi
DOCKER_CLI_PINNED_HOST="$context_host"
DOCKER_CLI_ENDPOINT_SOURCE=context
}
docker_cli_env_resolve_endpoint() {
if [[ -n "${DOCKER_HOST:-}" ]]; then
docker_cli_env_validate_local_endpoint "$DOCKER_HOST" || return $?
DOCKER_CLI_PINNED_HOST="$DOCKER_HOST"
DOCKER_CLI_ENDPOINT_SOURCE=explicit_host
return 0
fi
docker_cli_env_resolve_context_endpoint
}
docker_cli_env_apply_pinned_endpoint() {
[[ -n "$DOCKER_CLI_PINNED_HOST" ]] || {
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: no approved local Docker endpoint was resolved"
return 1
}
# DOCKER_HOST intentionally wins after this point. Clearing DOCKER_CONTEXT
# removes both its documented precedence and any dependency on context files
# that are absent from the isolated task/private configs.
export DOCKER_HOST="$DOCKER_CLI_PINNED_HOST"
unset DOCKER_CONTEXT 2>/dev/null || true
if [[ "$DOCKER_CLI_ENDPOINT_SOURCE" == context ]]; then
# Context-derived local/rootless Unix endpoints do not use ambient TLS.
# Loopback context endpoints with TLS were rejected during resolution.
unset DOCKER_TLS DOCKER_TLS_VERIFY DOCKER_CERT_PATH 2>/dev/null || true
fi
}
docker_cli_env_find_buildx() {
local explicit="${MINIKUBE_DOCKER_BUILDX_PLUGIN:-}"
local candidate
if [[ -n "$explicit" ]]; then
if [[ ! -f "$explicit" || ! -x "$explicit" ]]; then
docker_cli_env_error "DOCKER_BUILDX_REQUIRED: the explicitly configured buildx plugin is not executable"
return 1
fi
printf '%s\n' "$explicit"
return 0
fi
# Docker Desktop and the official Linux packages install buildx in one of
# these CLI-owned locations. User Docker config directories are deliberately
# excluded because they sit beside ambient auth and credential-helper state.
for candidate in \
/Applications/Docker.app/Contents/Resources/cli-plugins/docker-buildx \
/usr/local/lib/docker/cli-plugins/docker-buildx \
/opt/homebrew/lib/docker/cli-plugins/docker-buildx \
/usr/libexec/docker/cli-plugins/docker-buildx \
/usr/lib/docker/cli-plugins/docker-buildx; do
if [[ -f "$candidate" && -x "$candidate" ]]; then
printf '%s\n' "$candidate"
return 0
fi
done
return 1
}
docker_cli_run_with_config() {
local config="$1" label="$2" timeout_seconds="$3"
shift 3
docker_cli_env_validate_local_endpoint "${DOCKER_HOST:-}" || return $?
(
# This override intentionally belongs only to the child operation.
# shellcheck disable=SC2030
export DOCKER_CONFIG="$config"
unset DOCKER_AUTH_CONFIG DOCKER_CONTEXT DOCKER_CUSTOM_HEADERS
node "$DOCKER_CLI_DEADLINE_RUNNER" \
--timeout-seconds "$timeout_seconds" \
--heartbeat-seconds "$MINIKUBE_DOCKER_HEARTBEAT_SECONDS" \
--kill-grace-seconds "$MINIKUBE_DOCKER_KILL_GRACE_SECONDS" \
--label "$label" -- "$@"
)
}
docker_cli_env_verify_pinned_endpoint() {
local effective_host="" status=0
effective_host="$(
docker_cli_run_with_config "$DOCKER_CLI_TASK_CONFIG" docker-endpoint-verify \
"$MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS" \
docker context inspect --format '{{.Endpoints.docker.Host}}' default
)" || status=$?
if [[ "$status" -ne 0 ]]; then
docker_cli_env_error "DOCKER_ENDPOINT_REQUIRED: the isolated Docker config could not verify its endpoint"
return "$status"
fi
if [[ "$effective_host" != "$DOCKER_CLI_PINNED_HOST" ]]; then
docker_cli_env_error "DOCKER_ENDPOINT_MISMATCH: the isolated Docker config selected a different endpoint"
return 1
fi
}
docker_cli_run_public() {
local label="$1" timeout_seconds="$2"
shift 2
if [[ -z "$DOCKER_CLI_TASK_CONFIG" || ! -d "$DOCKER_CLI_TASK_CONFIG" ]]; then
docker_cli_env_error "DOCKER_CONFIG_REQUIRED: docker_cli_env_prepare must run before Docker operations"
return 1
fi
docker_cli_run_with_config "$DOCKER_CLI_TASK_CONFIG" "$label" "$timeout_seconds" "$@"
}
docker_cli_env_require_auth_config() {
local requested="${MINIKUBE_DOCKER_AUTH_CONFIG:-}"
if [[ -z "$requested" ]]; then
docker_cli_env_error "REGISTRY_AUTH_REQUIRED: set MINIKUBE_DOCKER_AUTH_CONFIG to an explicit Docker config directory"
return 1
fi
if [[ ! -d "$requested" || ! -f "$requested/config.json" || ! -r "$requested/config.json" ]]; then
docker_cli_env_error "REGISTRY_AUTH_REQUIRED: the explicit Docker config directory is not readable"
return 1
fi
DOCKER_CLI_AUTH_CONFIG="$(cd -- "$requested" && pwd -P)" || {
docker_cli_env_error "REGISTRY_AUTH_REQUIRED: the explicit Docker config directory cannot be resolved"
return 1
}
}
docker_cli_run_private() {
local label="$1" timeout_seconds="$2"
shift 2
docker_cli_env_require_auth_config || return $?
docker_cli_run_with_config "$DOCKER_CLI_AUTH_CONFIG" "$label" "$timeout_seconds" "$@"
}
docker_cli_env_prepare() {
local validate_buildx="${1:-true}"
local temp_root old_umask buildx_path="" buildx_status=0
if [[ -n "$DOCKER_CLI_TASK_CONFIG" && -d "$DOCKER_CLI_TASK_CONFIG" ]]; then
return 0
fi
case "$validate_buildx" in
true|false) ;;
*)
docker_cli_env_error "DOCKER_CONFIG_REQUIRED: buildx validation mode must be true or false"
return 2
;;
esac
command -v node >/dev/null 2>&1 || {
docker_cli_env_error "DOCKER_DEADLINE_REQUIRED: node is required for bounded Docker operations"
return 1
}
command -v docker >/dev/null 2>&1 || {
docker_cli_env_error "DOCKER_CLI_REQUIRED: docker is not installed"
return 1
}
[[ -f "$DOCKER_CLI_DEADLINE_RUNNER" ]] || {
docker_cli_env_error "DOCKER_DEADLINE_REQUIRED: the deadline runner is missing"
return 1
}
if [[ "$validate_buildx" == true ]]; then
docker_cli_env_validate_deadlines || return $?
else
docker_cli_env_validate_seconds MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS \
"$MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS" 300 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_HEARTBEAT_SECONDS \
"$MINIKUBE_DOCKER_HEARTBEAT_SECONDS" 300 || return $?
docker_cli_env_validate_seconds MINIKUBE_DOCKER_KILL_GRACE_SECONDS \
"$MINIKUBE_DOCKER_KILL_GRACE_SECONDS" 30 || return $?
fi
# Resolve while the caller's context metadata is still available, then pin
# the approved local endpoint before replacing the Docker configuration.
docker_cli_env_resolve_endpoint || return $?
temp_root="${TMPDIR:-/tmp}"
[[ -d "$temp_root" ]] || {
docker_cli_env_error "DOCKER_CONFIG_REQUIRED: the temporary directory is unavailable"
return 1
}
old_umask="$(umask)"
umask 077
DOCKER_CLI_TASK_CONFIG="$(mktemp -d "${temp_root%/}/evenfire-minikube-docker.XXXXXX")" || {
umask "$old_umask"
docker_cli_env_error "DOCKER_CONFIG_REQUIRED: could not create the isolated Docker config"
return 1
}
mkdir -p "$DOCKER_CLI_TASK_CONFIG/cli-plugins"
printf '{}\n' >"$DOCKER_CLI_TASK_CONFIG/config.json"
chmod 700 "$DOCKER_CLI_TASK_CONFIG" "$DOCKER_CLI_TASK_CONFIG/cli-plugins"
chmod 600 "$DOCKER_CLI_TASK_CONFIG/config.json"
umask "$old_umask"
docker_cli_env_apply_pinned_endpoint || return $?
# The task config must also become the caller's active config.
# shellcheck disable=SC2031
export DOCKER_CONFIG="$DOCKER_CLI_TASK_CONFIG"
unset DOCKER_AUTH_CONFIG 2>/dev/null || true
docker_cli_env_verify_pinned_endpoint || return $?
if [[ "$validate_buildx" == false ]]; then
return 0
fi
if [[ -n "${MINIKUBE_DOCKER_BUILDX_PLUGIN:-}" ]]; then
buildx_path="$(docker_cli_env_find_buildx)" || return $?
ln -s "$buildx_path" "$DOCKER_CLI_TASK_CONFIG/cli-plugins/docker-buildx"
elif buildx_path="$(docker_cli_env_find_buildx)"; then
ln -s "$buildx_path" "$DOCKER_CLI_TASK_CONFIG/cli-plugins/docker-buildx"
fi
# A system-integrated plugin may work even when no explicit file candidate
# was found. Validate through the isolated config and never download a plugin.
docker_cli_run_public buildx-version "$MINIKUBE_DOCKER_INFO_TIMEOUT_SECONDS" \
docker buildx version >/dev/null 2>&1 || buildx_status=$?
if [[ "$buildx_status" -ne 0 ]]; then
docker_cli_env_error "DOCKER_BUILDX_REQUIRED: no usable installed buildx plugin was found"
return "$buildx_status"
fi
}
docker_cli_wait_for_info() {
docker_cli_env_validate_startup_deadlines || return $?
# The literal script is intentional: poll_seconds is positional data passed
# to the child shell, while the outer deadline owns the whole process group.
# shellcheck disable=SC2016
docker_cli_run_public docker-info-startup-wait "$MINIKUBE_DOCKER_START_TIMEOUT_SECONDS" \
bash -c '
poll_seconds="$1"
while ! docker info >/dev/null 2>&1; do
sleep "$poll_seconds"
done
' _ "$MINIKUBE_DOCKER_START_POLL_SECONDS"
}
docker_cli_env_cleanup() {
local task_config="$DOCKER_CLI_TASK_CONFIG" cleanup_status=0
DOCKER_CLI_TASK_CONFIG=""
DOCKER_CLI_AUTH_CONFIG=""
DOCKER_CLI_PINNED_HOST=""
DOCKER_CLI_ENDPOINT_SOURCE=""
if [[ -n "$task_config" ]]; then
case "${task_config##*/}" in
evenfire-minikube-docker.*)
if [[ -d "$task_config" && ! -L "$task_config" ]]; then
rm -rf -- "$task_config" || cleanup_status=$?
fi
;;
*)
docker_cli_env_error "DOCKER_CONFIG_CLEANUP_REFUSED: unexpected task config path"
cleanup_status=1
;;
esac
fi
docker_cli_env_restore_variable DOCKER_CONFIG "$DOCKER_CLI_ORIGINAL_CONFIG_SET" "$DOCKER_CLI_ORIGINAL_CONFIG"
docker_cli_env_restore_variable DOCKER_AUTH_CONFIG "$DOCKER_CLI_ORIGINAL_AUTH_SET" "$DOCKER_CLI_ORIGINAL_AUTH"
docker_cli_env_restore_variable DOCKER_CONTEXT "$DOCKER_CLI_ORIGINAL_CONTEXT_SET" "$DOCKER_CLI_ORIGINAL_CONTEXT"
docker_cli_env_restore_variable DOCKER_HOST "$DOCKER_CLI_ORIGINAL_HOST_SET" "$DOCKER_CLI_ORIGINAL_HOST"
docker_cli_env_restore_variable DOCKER_TLS "$DOCKER_CLI_ORIGINAL_TLS_SET" "$DOCKER_CLI_ORIGINAL_TLS"
docker_cli_env_restore_variable DOCKER_TLS_VERIFY "$DOCKER_CLI_ORIGINAL_TLS_VERIFY_SET" "$DOCKER_CLI_ORIGINAL_TLS_VERIFY"
docker_cli_env_restore_variable DOCKER_CERT_PATH "$DOCKER_CLI_ORIGINAL_CERT_PATH_SET" "$DOCKER_CLI_ORIGINAL_CERT_PATH"
docker_cli_env_restore_variable DOCKER_API_VERSION "$DOCKER_CLI_ORIGINAL_API_VERSION_SET" "$DOCKER_CLI_ORIGINAL_API_VERSION"
docker_cli_env_restore_variable DOCKER_CUSTOM_HEADERS "$DOCKER_CLI_ORIGINAL_CUSTOM_HEADERS_SET" "$DOCKER_CLI_ORIGINAL_CUSTOM_HEADERS"
docker_cli_env_restore_variable MINIKUBE_ACTIVE_DOCKERD "$DOCKER_CLI_ORIGINAL_MINIKUBE_ACTIVE_SET" "$DOCKER_CLI_ORIGINAL_MINIKUBE_ACTIVE"
return "$cleanup_status"
}
docker_cli_env_restore_variable() {
local name="$1" was_set="$2" value="$3"
if [[ "$was_set" == x ]]; then
printf -v "$name" '%s' "$value"
export "${name?}"
else
unset "$name" 2>/dev/null || true
fi
}
docker_cli_env_main_cleanup() {
local status=$? cleanup_status=0
trap - EXIT HUP QUIT INT TERM
docker_cli_env_cleanup || cleanup_status=$?
if [[ "$status" -eq 0 && "$cleanup_status" -ne 0 ]]; then
status="$cleanup_status"
fi
exit "$status"
}
docker_cli_env_main() {
if [[ "$#" -ne 1 ]]; then
docker_cli_env_error "usage: ${0##*/} --check-info | --wait-for-info"
return 2
fi
# Startup probes do not build images, so requiring buildx here would delay or
# block Docker Desktop startup for an unrelated plugin. They still use the
# same empty task-local config and process-group deadline runner.
docker_cli_env_prepare false || return $?
docker_cli_env_validate_startup_deadlines || return $?
case "$1" in
--check-info)
docker_cli_run_public docker-info-startup-probe \
"$MINIKUBE_DOCKER_START_PROBE_TIMEOUT_SECONDS" docker info >/dev/null
;;
--wait-for-info)
docker_cli_wait_for_info
;;
*)
docker_cli_env_error "usage: ${0##*/} --check-info | --wait-for-info"
return 2
;;
esac
}
if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
set -euo pipefail
trap docker_cli_env_main_cleanup EXIT
trap 'exit 129' HUP
trap 'exit 131' QUIT
trap 'exit 130' INT
trap 'exit 143' TERM
docker_cli_env_main "$@"
fi