AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
#!/usr/bin/env bash
set -Eeuo pipefail
umask 077
readonly GHCR_IMAGE="ghcr.io/tianma-if/edgeever"
readonly TCR_IMAGE="ccr.ccs.tencentyun.com/edgeever/edgeever"
readonly GLOBAL_COMPOSE_URL="https://edgeever.org/compose.yaml"
readonly TENCENT_COMPOSE_URL="https://edgeever-installer-1256854452.cos.ap-guangzhou.myqcloud.com/compose.yaml"
install_dir="${EDGE_EVER_INSTALL_DIR:-${HOME:-}/edgeever}"
compose_url="${EDGE_EVER_COMPOSE_URL:-}"
image="${EDGE_EVER_IMAGE:-}"
version="${EDGE_EVER_VERSION:-}"
port="${EDGE_EVER_PORT:-}"
username="${EDGE_EVER_AUTH_USERNAME:-}"
password="${EDGE_EVER_AUTH_PASSWORD:-}"
project_name="${EDGE_EVER_PROJECT_NAME:-edgeever}"
auto_update="${EDGE_EVER_AUTO_UPDATE:-true}"
generated_password=false
temporary_compose=""
temporary_env=""
temporary_update=""
temporary_crontab=""
current_step="Parse arguments"
diagnostics_printed=false
start_epoch=0
auto_update_status="disabled"
declare -a compose=()
log() {
local level="$1"
shift
printf '[%s] [%-7s] %s\n' "$(date '+%H:%M:%S')" "$level" "$*" >&2
}
step() {
current_step="$2"
log "STEP $1/6" "$2"
}
print_storage_diagnostics() {
local container_id container_user mount_info mount_type mount_name mount_source probe_output
container_id="$("${compose[@]}" ps -q edgeever 2>/dev/null || true)"
container_user=""
mount_info=""
if [[ -n "$container_id" ]]; then
container_user="$(docker inspect --format '{{.Config.User}}' "$container_id" 2>/dev/null || true)"
mount_info="$(docker inspect --format '{{range .Mounts}}{{if eq .Destination "/data"}}{{.Type}}|{{.Name}}|{{.Source}}{{end}}{{end}}' "$container_id" 2>/dev/null || true)"
fi
log INFO "Persistent storage diagnostics:"
log INFO "Container user: ${container_user:-unknown} (EdgeEver expects UID/GID 1000:1000)"
if [[ -n "$mount_info" ]]; then
IFS='|' read -r mount_type mount_name mount_source <<< "$mount_info"
log INFO "/data mount: type=${mount_type:-unknown}, source=${mount_source:-unknown}${mount_name:+, volume=$mount_name}"
else
mount_type=""
mount_name=""
mount_source=""
log WARN "Could not identify the /data mount; inspect it with: docker inspect $container_id"
fi
if probe_output="$("${compose[@]}" run --rm --no-deps --entrypoint /bin/sh edgeever -c '
probe="/data/.edgeever-write-test-$$"
if (umask 077 && : > "$probe" && rm -f "$probe"); then
exit 0
fi
printf "EDGEEVER_DATA_WRITE_FAILED\n" >&2
printf "Runtime identity: " >&2
id >&2 || true
printf "Data directory: " >&2
ls -ldn /data >&2 || true
exit 73
' 2>&1)"; then
log INFO "/data write test: passed"
return 0
fi
if [[ "$probe_output" != *"EDGEEVER_DATA_WRITE_FAILED"* ]]; then
log WARN "/data write test: unavailable (the diagnostic container could not run)"
[[ -z "$probe_output" ]] || printf '%s\n' "$probe_output" | sed 's/^/ /' >&2
return 0
fi
log ERROR "/data write test: failed"
printf '%s\n' "$probe_output" | sed '/^EDGEEVER_DATA_WRITE_FAILED$/d; s/^/ /' >&2
if [[ "$mount_type" == "bind" && -n "$mount_source" ]]; then
log INFO "The NAS/host directory must be writable by UID/GID 1000:1000. Suggested repair:"
printf ' sudo chown -R 1000:1000 -- %q\n' "$mount_source" >&2
printf ' sudo chmod -R u+rwX -- %q\n' "$mount_source" >&2
log INFO "If the NAS uses ACL permissions, grant UID 1000 read/write access in its control panel too."
elif [[ "$mount_type" == "volume" ]]; then
log INFO "The Docker volume must be writable by UID/GID 1000:1000. Suggested repair:"
printf ' cd %q\n' "$install_dir" >&2
printf " docker compose --project-name %q run --rm --no-deps --user 0 --entrypoint /bin/sh edgeever -c 'chown -R 1000:1000 /data'\n" "$project_name" >&2
else
log INFO "Check the Compose /data mount and grant UID/GID 1000:1000 read/write access."
printf ' cd %q\n' "$install_dir" >&2
printf ' docker compose --project-name %q config\n' "$project_name" >&2
fi
}
usage() {
cat <<'EOF'
Install or upgrade EdgeEver with Docker Compose.
Usage:
curl -fsSL https://edgeever.org/install.sh | bash
Options:
--image IMAGE Use a custom image repository
--version TAG Deploy an image tag (default: latest)
--compose-url URL Download Compose configuration from URL
--install-dir DIR Store Compose configuration in DIR (default: ~/edgeever)
--port PORT Publish EdgeEver on PORT (default: 8787)
--auto-update Enable daily automatic updates (default)
--no-auto-update Disable daily automatic updates
-h, --help Show this help
The same options can be provided with EDGE_EVER_IMAGE, EDGE_EVER_VERSION,
EDGE_EVER_COMPOSE_URL, EDGE_EVER_INSTALL_DIR, EDGE_EVER_PORT, and
EDGE_EVER_AUTH_PASSWORD. Set EDGE_EVER_AUTO_UPDATE=false to disable automatic
updates.
EOF
}
print_diagnostics() {
[[ "$diagnostics_printed" == false ]] || return 0
diagnostics_printed=true
log ERROR "Stage: $current_step"
if ((${#compose[@]} > 0)); then
log INFO "Container status:"
"${compose[@]}" ps -a >&2 || true
log INFO "Recent container logs:"
"${compose[@]}" logs --tail 80 edgeever >&2 || true
print_storage_diagnostics || true
log INFO "Troubleshooting commands:"
printf ' cd %q\n' "$install_dir" >&2
printf ' docker compose --project-name %q --env-file .env --file compose.yaml ps -a\n' "$project_name" >&2
printf ' docker compose --project-name %q --env-file .env --file compose.yaml logs --tail 200 edgeever\n' "$project_name" >&2
fi
log INFO "Deployment guide: https://github.com/tianma-if/edgeever/blob/main/docs/deploy-docker.md"
}
fail() {
trap - ERR
log ERROR "$*"
print_diagnostics
exit 1
}
on_error() {
local exit_code=$?
local line_number="${BASH_LINENO[0]}"
trap - ERR
log ERROR "A command failed (exit code: $exit_code, line: $line_number)"
print_diagnostics
exit "$exit_code"
}
trap on_error ERR
require_value() {
[[ $# -ge 2 && -n "$2" ]] || fail "$1 requires a value"
}
while [[ $# -gt 0 ]]; do
case "$1" in
--mirror)
require_value "$@"
case "$2" in
ghcr) image="$GHCR_IMAGE" ;;
tcr) image="$TCR_IMAGE" ;;
*) fail "--mirror must be ghcr or tcr" ;;
esac
shift 2
;;
--image)
require_value "$@"
image="$2"
shift 2
;;
--version)
require_value "$@"
version="$2"
shift 2
;;
--compose-url)
require_value "$@"
compose_url="$2"
shift 2
;;
--install-dir)
require_value "$@"
install_dir="$2"
shift 2
;;
--port)
require_value "$@"
port="$2"
shift 2
;;
--auto-update)
auto_update=true
shift
;;
--no-auto-update)
auto_update=false
shift
;;
-h|--help)
usage
exit 0
;;
*) fail "unknown option: $1" ;;
esac
done
start_epoch="$(date '+%s')"
step 1 "Validate environment"
[[ -n "$install_dir" ]] || fail "set HOME or EDGE_EVER_INSTALL_DIR"
[[ "$project_name" =~ ^[a-z0-9][a-z0-9_-]*$ ]] || fail "invalid EDGE_EVER_PROJECT_NAME"
command -v curl >/dev/null 2>&1 || fail "curl is required"
command -v docker >/dev/null 2>&1 || fail "Docker is required: https://docs.docker.com/engine/install/"
docker compose version >/dev/null 2>&1 || fail "Docker Compose v2 is required"
docker info >/dev/null 2>&1 || fail "cannot connect to the Docker daemon"
log INFO "Docker and Docker Compose are available"
host_os=""
if [[ -r /etc/os-release ]]; then
while IFS='=' read -r key value; do
if [[ "$key" == "PRETTY_NAME" ]]; then
host_os="${value#\"}"
host_os="${host_os%\"}"
break
fi
done < /etc/os-release
fi
host_os="${host_os:-$(uname -s)}"
host_kernel_name="$(uname -s)"
kernel_version="$(uname -sr)"
host_architecture="$(uname -m)"
docker_engine_version="$(docker version --format '{{.Server.Version}}' 2>/dev/null || true)"
docker_engine_version="${docker_engine_version:-unknown}"
docker_compose_version="$(docker compose version --short 2>/dev/null || true)"
docker_compose_version="${docker_compose_version:-unknown}"
log INFO "Host OS: $host_os"
log INFO "Kernel: $kernel_version"
log INFO "Architecture: $host_architecture"
log INFO "Docker Engine: $docker_engine_version"
log INFO "Docker Compose: $docker_compose_version"
if [[ "$host_kernel_name" == "Linux" ]]; then
kernel_release="$(uname -r)"
kernel_major="${kernel_release%%.*}"
kernel_remainder="${kernel_release#*.}"
kernel_minor="${kernel_remainder%%.*}"
if [[ "$kernel_major" =~ ^[0-9]+$ && "$kernel_minor" =~ ^[0-9]+$ ]] \
&& ((kernel_major < 5 || (kernel_major == 5 && kernel_minor < 6))); then
log WARN "Linux kernel $kernel_release does not meet EdgeEver's minimum 5.6 requirement"
log WARN "This host is outside the supported Docker environment and may fail while resolving container dependencies; upgrade the host OS/kernel if startup reports EISDIR"
fi
fi
mkdir -p "$install_dir"
env_file="$install_dir/.env"
compose_file="$install_dir/compose.yaml"
if [[ -f "$env_file" ]]; then
install_mode="upgrade"
else
install_mode="new installation"
fi
read_env_value() {
local key="$1"
local line value
[[ -f "$env_file" ]] || return 1
while IFS= read -r line; do
case "$line" in
"$key="*)
value="${line#*=}"
if [[ "$value" == "'"*"'" && ${#value} -ge 2 ]]; then
value="${value:1:${#value}-2}"
fi
printf '%s' "$value"
return 0
;;
esac
done < "$env_file"
return 1
}
step 2 "Resolve configuration"
if [[ -z "$image" ]]; then
image="$(read_env_value EDGE_EVER_IMAGE || true)"
image="${image:-$GHCR_IMAGE}"
fi
if [[ -z "$compose_url" ]]; then
if [[ "$image" == "$TCR_IMAGE" ]]; then
compose_url="$TENCENT_COMPOSE_URL"
else
compose_url="$GLOBAL_COMPOSE_URL"
fi
fi
if [[ -z "$version" ]]; then
version="$(read_env_value EDGE_EVER_VERSION || true)"
version="${version:-latest}"
fi
if [[ -z "$port" ]]; then
port="$(read_env_value EDGE_EVER_PORT || true)"
port="${port:-8787}"
fi
if [[ -z "$username" ]]; then
username="$(read_env_value EDGE_EVER_AUTH_USERNAME || true)"
username="${username:-admin}"
fi
if [[ -z "$password" ]]; then
password="$(read_env_value EDGE_EVER_AUTH_PASSWORD || true)"
fi
if [[ -z "$password" ]]; then
if command -v openssl >/dev/null 2>&1; then
password="$(openssl rand -hex 16)"
elif command -v od >/dev/null 2>&1; then
password="$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')"
else
fail "openssl or od is required to generate a password"
fi
generated_password=true
fi
[[ "$image" != *[[:space:]]* ]] || fail "image must not contain whitespace"
[[ "$version" != *[[:space:]]* ]] || fail "version must not contain whitespace"
[[ "$port" =~ ^[0-9]+$ ]] && ((port >= 1 && port <= 65535)) || fail "port must be between 1 and 65535"
[[ "$username" != *$'\n'* && "$username" != *"'"* ]] || fail "invalid administrator username"
[[ "$password" != *$'\n'* && "$password" != *"'"* ]] || fail "password must not contain a newline or single quote"
[[ "$auto_update" == "true" || "$auto_update" == "false" ]] || fail "EDGE_EVER_AUTO_UPDATE must be true or false"
log INFO "Mode: $install_mode"
log INFO "Install directory: $install_dir"
log INFO "EdgeEver target: $image:$version"
log INFO "Compose source: $compose_url"
log INFO "Published port: $port"
log INFO "Daily automatic updates: $auto_update"
cleanup() {
[[ -z "$temporary_compose" || ! -e "$temporary_compose" ]] || rm -f "$temporary_compose"
[[ -z "$temporary_env" || ! -e "$temporary_env" ]] || rm -f "$temporary_env"
[[ -z "$temporary_update" || ! -e "$temporary_update" ]] || rm -f "$temporary_update"
[[ -z "$temporary_crontab" || ! -e "$temporary_crontab" ]] || rm -f "$temporary_crontab"
return 0
}
trap cleanup EXIT
step 3 "Download Compose configuration"
temporary_compose="$(mktemp "$install_dir/.compose.yaml.XXXXXX")"
curl --fail --silent --show-error --location --output "$temporary_compose" "$compose_url"
grep -q '^services:' "$temporary_compose" || fail "downloaded Compose file is invalid"
chmod 0644 "$temporary_compose"
mv "$temporary_compose" "$compose_file"
temporary_compose=""
log INFO "Saved Compose configuration to $compose_file"
step 4 "Write runtime configuration"
temporary_env="$(mktemp "$install_dir/.env.XXXXXX")"
{
printf "EDGE_EVER_IMAGE='%s'\n" "$image"
printf "EDGE_EVER_VERSION='%s'\n" "$version"
printf "EDGE_EVER_PORT='%s'\n" "$port"
printf "EDGE_EVER_AUTH_USERNAME='%s'\n" "$username"
printf "EDGE_EVER_AUTH_PASSWORD='%s'\n" "$password"
} > "$temporary_env"
chmod 0600 "$temporary_env"
mv "$temporary_env" "$env_file"
temporary_env=""
log INFO "Saved protected configuration to $env_file (password hidden)"
compose=(
docker compose
--project-name "$project_name"
--project-directory "$install_dir"
--env-file "$env_file"
--file "$compose_file"
)
write_auto_update_script() {
local update_script="$install_dir/update.sh"
local docker_command curl_command
docker_command="$(command -v docker)"
curl_command="$(command -v curl)"
temporary_update="$(mktemp "$install_dir/.update.sh.XXXXXX")"
{
printf '#!/usr/bin/env bash\n\n'
printf 'set -Eeuo pipefail\n'
printf 'umask 077\n\n'
printf 'readonly docker_command=%q\n' "$docker_command"
printf 'readonly curl_command=%q\n' "$curl_command"
printf 'readonly install_dir=%q\n' "$install_dir"
printf 'readonly compose_url=%q\n' "$compose_url"
printf 'readonly project_name=%q\n\n' "$project_name"
cat <<'EOF'
env_file="$install_dir/.env"
compose_file="$install_dir/compose.yaml"
lock_file="$install_dir/.update.lock"
temporary_compose=""
log() {
printf '[%s] [EdgeEver update] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$*"
}
print_storage_diagnostics() {
local container_id container_user mount_info mount_type mount_name mount_source probe_output
container_id="$("${compose[@]}" ps -q edgeever 2>/dev/null || true)"
container_user=""
mount_info=""
if [[ -n "$container_id" ]]; then
container_user="$("$docker_command" inspect --format '{{.Config.User}}' "$container_id" 2>/dev/null || true)"
mount_info="$("$docker_command" inspect --format '{{range .Mounts}}{{if eq .Destination "/data"}}{{.Type}}|{{.Name}}|{{.Source}}{{end}}{{end}}' "$container_id" 2>/dev/null || true)"
fi
log "Persistent storage diagnostics:"
log "Container user: ${container_user:-unknown} (EdgeEver expects UID/GID 1000:1000)."
if [[ -n "$mount_info" ]]; then
IFS='|' read -r mount_type mount_name mount_source <<< "$mount_info"
log "/data mount: type=${mount_type:-unknown}, source=${mount_source:-unknown}${mount_name:+, volume=$mount_name}."
else
mount_type=""
mount_name=""
mount_source=""
log "Could not identify the /data mount."
fi
if probe_output="$("${compose[@]}" run --rm --no-deps --entrypoint /bin/sh edgeever -c '
probe="/data/.edgeever-write-test-$$"
if (umask 077 && : > "$probe" && rm -f "$probe"); then
exit 0
fi
printf "EDGEEVER_DATA_WRITE_FAILED\n" >&2
printf "Runtime identity: " >&2
id >&2 || true
printf "Data directory: " >&2
ls -ldn /data >&2 || true
exit 73
' 2>&1)"; then
log "/data write test: passed."
return 0
fi
if [[ "$probe_output" != *"EDGEEVER_DATA_WRITE_FAILED"* ]]; then
log "/data write test: unavailable (the diagnostic container could not run)."
[[ -z "$probe_output" ]] || printf '%s\n' "$probe_output" | sed 's/^/ /'
return 0
fi
log "/data write test: failed."
printf '%s\n' "$probe_output" | sed '/^EDGEEVER_DATA_WRITE_FAILED$/d; s/^/ /'
if [[ "$mount_type" == "bind" && -n "$mount_source" ]]; then
log "Grant the NAS/host directory to UID/GID 1000:1000:"
printf ' sudo chown -R 1000:1000 -- %q\n' "$mount_source"
printf ' sudo chmod -R u+rwX -- %q\n' "$mount_source"
log "For NAS ACLs, also grant UID 1000 read/write access in the control panel."
elif [[ "$mount_type" == "volume" ]]; then
log "Repair the Docker volume ownership:"
printf ' cd %q\n' "$install_dir"
printf " %q compose --project-name %q run --rm --no-deps --user 0 --entrypoint /bin/sh edgeever -c 'chown -R 1000:1000 /data'\n" "$docker_command" "$project_name"
else
log "Inspect the Compose /data mount and grant UID/GID 1000:1000 read/write access."
fi
}
on_error() {
local exit_code=$?
local line_number="${BASH_LINENO[0]}"
trap - ERR
log "Update command failed (exit code: $exit_code, line: $line_number)."
if declare -p compose >/dev/null 2>&1; then
"${compose[@]}" ps -a || true
"${compose[@]}" logs --tail 80 edgeever || true
print_storage_diagnostics || true
fi
exit "$exit_code"
}
cleanup() {
[[ -z "$temporary_compose" || ! -e "$temporary_compose" ]] || rm -f "$temporary_compose"
}
trap on_error ERR
trap cleanup EXIT
if command -v flock >/dev/null 2>&1; then
exec 9>"$lock_file"
if ! flock -n 9; then
log "Another update is already running; skipping."
exit 0
fi
fi
compose=(
"$docker_command" compose
--project-name "$project_name"
--project-directory "$install_dir"
--env-file "$env_file"
--file "$compose_file"
)
log "Checking for updates."
temporary_compose="$(mktemp "$install_dir/.compose.yaml.XXXXXX")"
"$curl_command" --fail --silent --show-error --location --output "$temporary_compose" "$compose_url"
grep -q '^services:' "$temporary_compose"
chmod 0644 "$temporary_compose"
mv "$temporary_compose" "$compose_file"
temporary_compose=""
"${compose[@]}" pull
"${compose[@]}" up -d --remove-orphans
container_id=""
health=""
for _ in {1..60}; do
container_id="$("${compose[@]}" ps -q edgeever 2>/dev/null || true)"
if [[ -n "$container_id" ]]; then
health="$("$docker_command" inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$container_id" 2>/dev/null || true)"
[[ "$health" == "healthy" ]] && break
[[ "$health" == "exited" || "$health" == "dead" ]] && break
fi
sleep 2
done
if [[ "$health" != "healthy" ]]; then
"${compose[@]}" ps -a || true
"${compose[@]}" logs --tail 80 edgeever || true
log "Update failed: container health is ${health:-unknown}."
exit 1
fi
running_image="$("$docker_command" inspect --format '{{.Config.Image}}' "$container_id" 2>/dev/null || true)"
log "Update complete. Running image: ${running_image:-unknown}."
EOF
} > "$temporary_update"
chmod 0700 "$temporary_update"
mv "$temporary_update" "$update_script"
temporary_update=""
}
remove_auto_update_schedule() {
local marker="# edgeever-auto-update:$project_name"
local existing_line
command -v crontab >/dev/null 2>&1 || return 0
temporary_crontab="$(mktemp "$install_dir/.crontab.XXXXXX")"
while IFS= read -r existing_line; do
[[ "$existing_line" == *"$marker"* ]] || printf '%s\n' "$existing_line" >> "$temporary_crontab"
done < <(crontab -l 2>/dev/null || true)
if ! crontab "$temporary_crontab"; then
log WARN "Could not update the current user's crontab"
fi
rm -f "$temporary_crontab"
temporary_crontab=""
}
configure_auto_updates() {
local update_script="$install_dir/update.sh"
local update_log="$install_dir/update.log"
local marker="# edgeever-auto-update:$project_name"
local quoted_script quoted_log
if [[ "$auto_update" == "false" ]]; then
remove_auto_update_schedule
rm -f "$update_script"
auto_update_status="disabled"
log INFO "Daily automatic updates are disabled"
return 0
fi
write_auto_update_script
if ! command -v crontab >/dev/null 2>&1; then
auto_update_status="updater created at $update_script; cron is unavailable"
log WARN "crontab is unavailable; schedule $update_script with the NAS task scheduler"
return 0
fi
remove_auto_update_schedule
temporary_crontab="$(mktemp "$install_dir/.crontab.XXXXXX")"
crontab -l 2>/dev/null > "$temporary_crontab" || true
printf -v quoted_script '%q' "$update_script"
printf -v quoted_log '%q' "$update_log"
printf '17 4 * * * %s >> %s 2>&1 %s\n' "$quoted_script" "$quoted_log" "$marker" >> "$temporary_crontab"
if crontab "$temporary_crontab"; then
auto_update_status="daily at 04:17 server time; log: $update_log"
log INFO "Scheduled daily automatic updates at 04:17 server time"
else
auto_update_status="updater created at $update_script; cron installation failed"
log WARN "Could not install the cron schedule; run $update_script manually"
fi
rm -f "$temporary_crontab"
temporary_crontab=""
}
step 5 "Pull image and start container"
"${compose[@]}" pull
"${compose[@]}" up -d --remove-orphans
step 6 "Wait for health check"
container_id=""
health=""
for attempt in {1..60}; do
container_id="$("${compose[@]}" ps -q edgeever 2>/dev/null || true)"
if [[ -n "$container_id" ]]; then
health="$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$container_id" 2>/dev/null || true)"
[[ "$health" == "healthy" ]] && break
[[ "$health" == "exited" || "$health" == "dead" ]] && break
fi
if ((attempt == 1 || attempt % 5 == 0)); then
log INFO "Waiting for container health (status: ${health:-not started}, elapsed: $((attempt * 2))s)"
fi
sleep 2
done
if [[ "$health" != "healthy" ]]; then
fail "container did not become healthy (status: ${health:-unknown})"
fi
configure_auto_updates
running_image="$(docker inspect --format '{{.Config.Image}}' "$container_id" 2>/dev/null || true)"
log INFO "Running image: ${running_image:-$image:$version}"
log SUCCESS "EdgeEver is ready ($(($(date '+%s') - start_epoch))s)"
printf '\nConnection details\n'
printf ' URL: http://<server-ip>:%s\n' "$port"
printf ' Username: %s\n' "$username"
if [[ "$generated_password" == true ]]; then
printf ' Password: %s\n' "$password"
else
printf ' Password: unchanged (stored in %s)\n' "$env_file"
fi
printf ' Install directory: %s\n' "$install_dir"
printf ' Automatic updates: %s\n' "$auto_update_status"
printf '\nUseful commands\n'
printf ' cd %q\n' "$install_dir"
printf ' docker compose ps\n'
printf ' docker compose logs --tail 200 -f edgeever\n'
if [[ "$auto_update" == "true" ]]; then
printf ' ./update.sh\n'
fi