嗯，优化了显示顺序与部署逻辑的全新Deploy.sh

deploy.sh

@@ -34,13 +34,18 @@ DAEMON_JSON="/etc/docker/daemon.json"
 MIRROR_CHECK_TIMEOUT=5
 
 # ---------- 镜像加速状态变量 ----------
-MIRROR_STATUS=""                      # no_config | has_mirrors | default_unavailable
+MIRROR_STATUS=""                      # no_file | no_key | empty_array | has_valid_ordered | has_valid_reorder_needed | all_invalid
-NEED_RESTART=false                    # 是否需要重启 Docker
+DEFAULT_STATUS=""                     # default_unavailable | default_partial | default_all_available
-NEED_REORDER=false                    # 是否需要重排已有镜像源
+WRITE_DAEMON=false
-HAS_REGISTRY_MIRRORS_KEY=false        # daemon.json 中是否存在 registry-mirrors 字段
+RESTART_DOCKER=false
+REORDER=false
+INSERT_DEFAULT=false
+HAS_REGISTRY_MIRRORS_KEY=false
 AVAILABLE_MIRRORS=()                  # 可用的默认地址
 USER_MIRRORS_AVAILABLE=()             # 用户配置中可用的地址
 USER_MIRRORS_UNAVAILABLE=()           # 用户配置中不可用的地址
+USER_MIRRORS_ALL=()                   # 用户配置所有地址（保持原始顺序）
+MIRROR_DETECT_OUTPUT=""               # 检测阶段输出给用户的描述
 
 # ---------- 其他状态变量 ----------
 OS=""; OS_VERSION=""; ARCH=""
@@ -143,7 +148,6 @@ check_mirror_available() {
     http_code=$(curl -s --max-time "$MIRROR_CHECK_TIMEOUT" -o /dev/null -w "%{http_code}" \
         "${url}/v2/" 2>/dev/null)
     if [[ "$http_code" =~ ^2[0-9][0-9]$ ]] || [ "$http_code" = "401" ] || [ "$http_code" = "403" ]; then
-        # 2xx 表示成功，401/403 表示需要认证但服务可达（也是可用的）
         return 0
     fi
     return 1
@@ -188,9 +192,11 @@ check_docker_mirrors() {
 
     # 1. 检测三个默认地址的连通性
     print_info "检测默认镜像源连通性 (超时 ${MIRROR_CHECK_TIMEOUT}s)..."
+    local default_available_count=0
     for mirror in "${DEFAULT_MIRRORS[@]}"; do
         if check_mirror_available "$mirror"; then
             AVAILABLE_MIRRORS+=("$mirror")
+            default_available_count=$((default_available_count + 1))
             print_info "  ✅ $mirror 可用"
         else
             print_info "  ❌ $mirror 不可用"
@@ -198,19 +204,23 @@ check_docker_mirrors() {
     done
 
     if [ ${#AVAILABLE_MIRRORS[@]} -eq 0 ]; then
-        MIRROR_STATUS="default_unavailable"
+        DEFAULT_STATUS="default_unavailable"
         print_warn "所有默认镜像源均不可用，将跳过镜像加速配置"
-        print_warn "如果 Docker 构建失败，请检查网络或手动配置镜像源"
+    elif [ ${#AVAILABLE_MIRRORS[@]} -eq ${#DEFAULT_MIRRORS[@]} ]; then
-        return 0
+        DEFAULT_STATUS="default_all_available"
+        print_success "所有默认镜像源均可用"
+    else
+        DEFAULT_STATUS="default_partial"
+        print_info "部分默认镜像源可用 (${#AVAILABLE_MIRRORS[@]}/${#DEFAULT_MIRRORS[@]})"
     fi
 
-    print_success "找到 ${#AVAILABLE_MIRRORS[@]} 个可用默认镜像源"
-
     # 2. 检查 daemon.json
     if [ ! -f "$DAEMON_JSON" ]; then
-        MIRROR_STATUS="no_config"
+        MIRROR_STATUS="no_file"
         HAS_REGISTRY_MIRRORS_KEY=false
-        print_info "daemon.json 不存在，将创建新配置"
+        print_info "daemon.json 不存在"
+        # 生成检测报告
+        generate_mirror_detect_output
         return 0
     fi
 
@@ -222,8 +232,9 @@ check_docker_mirrors() {
         print_info "已备份至: $backup_path"
         echo '{}' > "$DAEMON_JSON"
         print_warn "已重建 daemon.json，请确认是否需要将其他自定义配置迁回"
-        MIRROR_STATUS="no_config"
+        MIRROR_STATUS="no_file"
         HAS_REGISTRY_MIRRORS_KEY=false
+        generate_mirror_detect_output
         return 0
     fi
 
@@ -232,8 +243,9 @@ check_docker_mirrors() {
     has_key=$(jq -e 'has("registry-mirrors")' "$DAEMON_JSON" 2>/dev/null)
     if [ "$has_key" != "true" ]; then
         HAS_REGISTRY_MIRRORS_KEY=false
-        MIRROR_STATUS="has_mirrors"
+        MIRROR_STATUS="no_key"
-        print_info "daemon.json 中无 registry-mirrors 字段，将仅插入该字段（保留其他配置）"
+        print_info "daemon.json 中无 registry-mirrors 字段"
+        generate_mirror_detect_output
         return 0
     fi
 
@@ -243,120 +255,219 @@ check_docker_mirrors() {
     local mirror_list
     mirror_list=$(jq -r '."registry-mirrors" // [] | .[]' "$DAEMON_JSON" 2>/dev/null)
     if [ -z "$mirror_list" ]; then
-        MIRROR_STATUS="has_mirrors"
+        MIRROR_STATUS="empty_array"
-        print_info "registry-mirrors 为空数组，将写入默认地址"
+        print_info "registry-mirrors 为空数组"
+        generate_mirror_detect_output
         return 0
     fi
 
-    # 6. 检测用户配置中每个地址的连通性
+    # 6. 读取用户配置所有地址（保持顺序）
+    USER_MIRRORS_ALL=()
+    while IFS= read -r mirror; do
+        if [ -n "$mirror" ]; then
+            USER_MIRRORS_ALL+=("$mirror")
+        fi
+    done <<< "$mirror_list"
+
+    # 7. 检测用户配置中每个地址的连通性
     print_info "检测用户配置的镜像源连通性..."
     USER_MIRRORS_AVAILABLE=()
     USER_MIRRORS_UNAVAILABLE=()
 
-    while IFS= read -r mirror; do
+    for mirror in "${USER_MIRRORS_ALL[@]}"; do
-        if [ -n "$mirror" ]; then
+        if check_mirror_available "$mirror"; then
-            if check_mirror_available "$mirror"; then
+            USER_MIRRORS_AVAILABLE+=("$mirror")
-                USER_MIRRORS_AVAILABLE+=("$mirror")
+            print_info "  ✅ $mirror (用户配置) 可用"
-                print_info "  ✅ $mirror (用户配置) 可用"
+        else
-            else
+            USER_MIRRORS_UNAVAILABLE+=("$mirror")
-                USER_MIRRORS_UNAVAILABLE+=("$mirror")
+            print_info "  ❌ $mirror (用户配置) 不可用"
-                print_info "  ❌ $mirror (用户配置) 不可用"
-            fi
         fi
-    done <<< "$mirror_list"
+    done
 
-    MIRROR_STATUS="has_mirrors"
+    # 8. 判断状态
-
-    # 7. 判断是否需要重排
     if [ ${#USER_MIRRORS_AVAILABLE[@]} -gt 0 ]; then
-        # 检查可用地址是否已经全部排在不可用地址前面
+        # 检查是否需要重排：是否存在不可用在可用之前
-        NEED_REORDER=false
+        local need_reorder=false
         local seen_unavailable=false
-        for mirror in "${USER_MIRRORS_AVAILABLE[@]}" "${USER_MIRRORS_UNAVAILABLE[@]}"; do
+        for mirror in "${USER_MIRRORS_ALL[@]}"; do
-            # 遍历原始顺序：在 USER_MIRRORS_AVAILABLE 和 USER_MIRRORS_UNAVAILABLE 的拼接中，
+            local is_avail=false
-            # 如果先遇到不可用，再遇到可用，说明需要重排
+            for a in "${USER_MIRRORS_AVAILABLE[@]}"; do
-            # 但我们这里无法直接还原原始顺序，用另一个方法：检查原始列表中是否存在可用在不可用之后
+                if [ "$a" = "$mirror" ]; then
-            # 更简单的方法：如果存在任何一个不可用在可用之前
+                    is_avail=true
-            # 用原始列表检测
+                    break
-            local raw_list
-            raw_list=$(jq -r '."registry-mirrors" // [] | .[]' "$DAEMON_JSON" 2>/dev/null)
-            local raw_available=()
-            local raw_unavailable=()
-            while IFS= read -r m; do
-                if [ -n "$m" ]; then
-                    local found=false
-                    for a in "${USER_MIRRORS_AVAILABLE[@]}"; do
-                        if [ "$a" = "$m" ]; then
-                            raw_available+=("$m")
-                            found=true
-                            break
-                        fi
-                    done
-                    if [ "$found" = false ]; then
-                        raw_unavailable+=("$m")
-                    fi
                 fi
-            done <<< "$raw_list"
-
-            # 检查原始列表中，是否有不可用地址出现在可用地址之前
-            local seen_avail=false
-            for m in "${raw_available[@]}" "${raw_unavailable[@]}"; do
-                # 这里只检查原始顺序
-                true
             done
-
+            if [ "$is_avail" = true ] && [ "$seen_unavailable" = true ]; then
-            # 更准确的方法：遍历原始列表，记录是否见过不可用
+                need_reorder=true
-            local seen_unavail=false
+                break
-            local need_reorder=false
+            fi
-            while IFS= read -r m; do
+            if [ "$is_avail" = false ]; then
-                if [ -n "$m" ]; then
+                seen_unavailable=true
-                    local is_avail=false
+            fi
-                    for a in "${USER_MIRRORS_AVAILABLE[@]}"; do
-                        if [ "$a" = "$m" ]; then
-                            is_avail=true
-                            break
-                        fi
-                    done
-                    if [ "$is_avail" = true ] && [ "$seen_unavail" = true ]; then
-                        need_reorder=true
-                        break
-                    fi
-                    if [ "$is_avail" = false ]; then
-                        seen_unavail=true
-                    fi
-                fi
-            done <<< "$raw_list"
-            NEED_REORDER=$need_reorder
         done
 
-        if [ "$NEED_REORDER" = true ]; then
+        if [ "$need_reorder" = true ]; then
-            print_info "检测到可用镜像源排在不可用镜像源之后，需要重排"
+            MIRROR_STATUS="has_valid_reorder_needed"
+            print_info "可用镜像源排在不可用镜像源之后，需要重排"
         else
+            MIRROR_STATUS="has_valid_ordered"
             print_info "用户镜像源配置正常，无需调整"
         fi
-    elif [ ${#USER_MIRRORS_UNAVAILABLE[@]} -gt 0 ] && [ ${#AVAILABLE_MIRRORS[@]} -gt 0 ]; then
+    else
-        # 用户配置全部不可用，但有可用的默认地址
+        # 用户配置全部不可用
-        NEED_REORDER=true
+        MIRROR_STATUS="all_invalid"
-        print_info "用户配置全部不可用，将插入可用默认地址"
+        print_warn "用户配置全部不可用"
     fi
 
-    print_success "镜像源检测完成"
+    generate_mirror_detect_output
+}
+
+# ---------- 镜像加速：生成检测输出 ----------
+generate_mirror_detect_output() {
+    MIRROR_DETECT_OUTPUT=""
+
+    # 如果默认地址全部不可用，直接输出警告
+    if [ "$DEFAULT_STATUS" = "default_unavailable" ]; then
+        MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}⚠ 所有默认镜像源均不可用，将跳过镜像加速配置${NC}\n"
+        MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}如果 Docker 构建失败，请检查网络或手动配置镜像源。\n"
+        return
+    fi
+
+    # 构建可用地址列表显示
+    local avail_list=""
+    for m in "${AVAILABLE_MIRRORS[@]}"; do
+        avail_list="${avail_list}  ✓ ${m}\n"
+    done
+
+    case "$MIRROR_STATUS" in
+        no_file|no_key|empty_array)
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}未检测到 registry-mirrors 配置。${NC}\n\n"
+            if [ ${#AVAILABLE_MIRRORS[@]} -gt 0 ]; then
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}将写入以下可用镜像源：\n\n${avail_list}\n"
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}写入位置：${DAEMON_JSON}\n"
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}Docker 将在配置完成后自动重启以应用配置。${NC}\n"
+                WRITE_DAEMON=true
+                RESTART_DOCKER=true
+                REORDER=false
+                INSERT_DEFAULT=true
+            else
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${RED}无可用的默认镜像源，将跳过配置。${NC}\n"
+                WRITE_DAEMON=false
+                RESTART_DOCKER=false
+                REORDER=false
+                INSERT_DEFAULT=false
+            fi
+            ;;
+
+        has_valid_ordered)
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${GREEN}检测完成。用户已配置可用的镜像源：${NC}\n\n"
+            for m in "${USER_MIRRORS_AVAILABLE[@]}"; do
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ✓ ${m}\n"
+            done
+            if [ ${#USER_MIRRORS_UNAVAILABLE[@]} -gt 0 ]; then
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${YELLOW}不可用地址：${NC}\n"
+                for m in "${USER_MIRRORS_UNAVAILABLE[@]}"; do
+                    MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ✗ ${m}\n"
+                done
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n可用地址已排在不可用地址之前，无需修改。\n"
+            else
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n所有地址均可用，无需修改。\n"
+            fi
+            WRITE_DAEMON=false
+            RESTART_DOCKER=false
+            REORDER=false
+            INSERT_DEFAULT=false
+            ;;
+
+        has_valid_reorder_needed)
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}检测完成。用户配置中存在不可用或顺序不当的镜像源。${NC}\n\n"
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}当前配置顺序：\n"
+            local idx=1
+            for m in "${USER_MIRRORS_ALL[@]}"; do
+                local status=""
+                local found=false
+                for a in "${USER_MIRRORS_AVAILABLE[@]}"; do
+                    if [ "$a" = "$m" ]; then
+                        found=true
+                        break
+                    fi
+                done
+                if [ "$found" = true ]; then
+                    status="${GREEN}✅ 可用${NC}"
+                else
+                    status="${RED}❌ 不可用${NC}"
+                fi
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ${idx}. ${m}  ${status}\n"
+                idx=$((idx + 1))
+            done
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${YELLOW}将重新排序：可用地址前置，不可用地址后移。${NC}\n"
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n新顺序：\n"
+            local new_idx=1
+            for m in "${USER_MIRRORS_AVAILABLE[@]}"; do
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ${new_idx}. ${m}  ${GREEN}✅${NC}\n"
+                new_idx=$((new_idx + 1))
+            done
+            for m in "${USER_MIRRORS_UNAVAILABLE[@]}"; do
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ${new_idx}. ${m}  ${RED}❌${NC}\n"
+                new_idx=$((new_idx + 1))
+            done
+            MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${YELLOW}Docker 将在配置完成后自动重启以应用配置。${NC}\n"
+            WRITE_DAEMON=true
+            RESTART_DOCKER=true
+            REORDER=true
+            INSERT_DEFAULT=false
+            ;;
+
+        all_invalid)
+            if [ ${#AVAILABLE_MIRRORS[@]} -gt 0 ]; then
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}检测完成。用户配置的镜像源全部不可用：${NC}\n\n"
+                for m in "${USER_MIRRORS_UNAVAILABLE[@]}"; do
+                    MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ✗ ${m}\n"
+                done
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${GREEN}检测到可用镜像源：${NC}\n\n"
+                for m in "${AVAILABLE_MIRRORS[@]}"; do
+                    MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ✓ ${m}\n"
+                done
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${YELLOW}将把可用地址插入到用户配置最前面。${NC}\n"
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}Docker 将在配置完成后自动重启以应用配置。${NC}\n"
+                WRITE_DAEMON=true
+                RESTART_DOCKER=true
+                REORDER=false
+                INSERT_DEFAULT=true
+            else
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${RED}检测完成。用户配置的镜像源全部不可用：${NC}\n\n"
+                for m in "${USER_MIRRORS_UNAVAILABLE[@]}"; do
+                    MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}  ✗ ${m}\n"
+                done
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}\n${RED}默认镜像源也全部不可用。将跳过镜像加速配置。${NC}\n"
+                MIRROR_DETECT_OUTPUT="${MIRROR_DETECT_OUTPUT}${YELLOW}如果 Docker 构建失败，请检查网络连接，或手动配置 /etc/docker/daemon.json 中的 registry-mirrors。${NC}\n"
+                WRITE_DAEMON=false
+                RESTART_DOCKER=false
+                REORDER=false
+                INSERT_DEFAULT=false
+            fi
+            ;;
+    esac
+
+    # 打印检测输出
+    echo ""
+    print_title
+    print_subtitle "Docker 镜像源检测结果"
+    echo ""
+    echo -e "$MIRROR_DETECT_OUTPUT"
+    print_title
+    echo ""
 }
 
 # ---------- 镜像加速：配置执行阶段 ----------
 configure_docker_mirrors() {
+    if [ "$WRITE_DAEMON" != true ]; then
+        print_info "无需修改 Docker 镜像源配置"
+        return 0
+    fi
+
     print_step "配置 Docker 镜像源..."
 
-    if [ "$MIRROR_STATUS" = "default_unavailable" ]; then
-        print_warn "无可用默认镜像源，跳过配置"
-        return 0
-    fi
-
-    if [ ${#AVAILABLE_MIRRORS[@]} -eq 0 ]; then
-        print_warn "无可用的默认镜像源，跳过配置"
-        return 0
-    fi
-
     # 确保 jq 可用
     if [ "$HAS_JQ" = false ]; then
         print_warn "jq 未安装，尝试安装..."
@@ -367,69 +478,35 @@ configure_docker_mirrors() {
         fi
     fi
 
+    # 构建新镜像列表
     local new_mirrors=()
-    local need_write=false
+    if [ "$REORDER" = true ]; then
-    local need_restart=false
+        # 重排：可用前置，不可用后移（仅重排用户配置）
-
+        new_mirrors=("${USER_MIRRORS_AVAILABLE[@]}" "${USER_MIRRORS_UNAVAILABLE[@]}")
-    # 情况判断
+        print_info "重排镜像源顺序"
-    if [ "$HAS_REGISTRY_MIRRORS_KEY" = false ]; then
+    elif [ "$INSERT_DEFAULT" = true ]; then
-        # 不存在 registry-mirrors 字段，直接插入
+        if [ "$MIRROR_STATUS" = "no_file" ] || [ "$MIRROR_STATUS" = "no_key" ] || [ "$MIRROR_STATUS" = "empty_array" ]; then
-        new_mirrors=("${AVAILABLE_MIRRORS[@]}")
+            # 无配置或空配置：直接写入可用默认地址
-        need_write=true
+            new_mirrors=("${AVAILABLE_MIRRORS[@]}")
-        need_restart=true
+            print_info "写入可用默认镜像源"
-        print_info "插入 registry-mirrors 字段: ${AVAILABLE_MIRRORS[*]}"
-    elif [ ${#USER_MIRRORS_AVAILABLE[@]} -eq 0 ] && [ ${#USER_MIRRORS_UNAVAILABLE[@]} -eq 0 ]; then
-        # 空数组，直接写入
-        new_mirrors=("${AVAILABLE_MIRRORS[@]}")
-        need_write=true
-        need_restart=true
-        print_info "写入 registry-mirrors: ${AVAILABLE_MIRRORS[*]}"
-    elif [ ${#USER_MIRRORS_AVAILABLE[@]} -gt 0 ]; then
-        if [ "$NEED_REORDER" = true ]; then
-            # 重排：可用地址在前 + 不可用地址在后（仅限用户配置中不可用的）
-            new_mirrors=("${USER_MIRRORS_AVAILABLE[@]}" "${USER_MIRRORS_UNAVAILABLE[@]}")
-            need_write=true
-            need_restart=true
-            print_info "重排镜像源: 可用前置"
         else
-            print_info "镜像源配置正常，无需修改"
+            # all_invalid：可用默认地址插入到最前面
-            return 0
+            new_mirrors=("${AVAILABLE_MIRRORS[@]}" "${USER_MIRRORS_UNAVAILABLE[@]}")
+            print_info "插入可用默认镜像源到最前面"
         fi
-    elif [ ${#USER_MIRRORS_AVAILABLE[@]} -eq 0 ] && [ ${#USER_MIRRORS_UNAVAILABLE[@]} -gt 0 ]; then
-        # 用户配置全部不可用，插入可用默认地址到最前面
-        new_mirrors=("${AVAILABLE_MIRRORS[@]}" "${USER_MIRRORS_UNAVAILABLE[@]}")
-        need_write=true
-        need_restart=true
-        print_info "插入可用默认镜像源到最前面: ${AVAILABLE_MIRRORS[*]}"
     else
         print_info "无需修改镜像源配置"
         return 0
     fi
 
-    if [ "$need_write" = false ]; then
+    # 备份 daemon.json
-        return 0
-    fi
-
-    # 检查是否需要重启 Docker（交互模式确认）
-    if [ "$need_restart" = true ] && [ "$SKIP_CONFIRM" != true ]; then
-        echo ""
-        echo -e "${YELLOW}⚠ 修改 Docker 镜像源配置需要重启 Docker 服务。${NC}"
-        echo -e "${YELLOW}  重启可能影响其他正在运行的容器。${NC}"
-        read -p "确认继续? [y/N]: " confirm </dev/tty
-        if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
-            print_info "已取消配置修改"
-            return 0
-        fi
-    fi
-
-    # 备份 daemon.json（如果存在且可读）
     if [ -f "$DAEMON_JSON" ]; then
         local backup_path="${DAEMON_JSON}.bak.$(date +%Y%m%d-%H%M%S)"
         cp "$DAEMON_JSON" "$backup_path"
         print_info "已备份: $backup_path"
     fi
 
-    # 写入新配置
+    # 写入新配置（仅修改 registry-mirrors 字段，保留其他所有字段）
     local json_mirrors
     json_mirrors=$(printf '%s\n' "${new_mirrors[@]}" | jq -R . | jq -s .)
 
@@ -441,9 +518,10 @@ configure_docker_mirrors() {
 
     mv "${DAEMON_JSON}.tmp" "$DAEMON_JSON"
     print_success "daemon.json 已更新"
+    print_info "新镜像源列表: ${new_mirrors[*]}"
 
     # 重启 Docker
-    if [ "$need_restart" = true ]; then
+    if [ "$RESTART_DOCKER" = true ]; then
         print_step "重启 Docker 服务..."
         if systemctl restart docker 2>/dev/null; then
             print_success "Docker 重启完成"
@@ -456,6 +534,7 @@ configure_docker_mirrors() {
     fi
 
     print_success "镜像源配置完成"
+    return 0
 }
 
 # ---------- 版本管理 ----------
@@ -573,22 +652,6 @@ print_environment_summary() {
         print_error "Docker 未安装，请先安装 Docker"
         exit 1
     fi
-    echo ""
-    echo "  ${CYAN}镜像源状态:${NC}"
-    if [ ${#AVAILABLE_MIRRORS[@]} -gt 0 ]; then
-        echo "    可用默认镜像源: ${AVAILABLE_MIRRORS[*]}"
-    else
-        echo "    可用默认镜像源: 无"
-    fi
-    if [ ${#USER_MIRRORS_AVAILABLE[@]} -gt 0 ]; then
-        echo "    用户配置可用: ${USER_MIRRORS_AVAILABLE[*]}"
-    elif [ ${#USER_MIRRORS_UNAVAILABLE[@]} -gt 0 ]; then
-        echo "    用户配置: ${#USER_MIRRORS_UNAVAILABLE[@]} 个地址均不可用"
-    elif [ "$HAS_REGISTRY_MIRRORS_KEY" = false ]; then
-        echo "    用户配置: 无 registry-mirrors"
-    else
-        echo "    用户配置: 无"
-    fi
     if [ "$CONTAINER_EXISTS" = true ]; then
         echo ""
         echo "  ${CYAN}容器状态:${NC}"
@@ -606,6 +669,15 @@ print_environment_summary() {
 # ---------- 部署计划 ----------
 generate_plan() {
     PLAN=""
+    # 按时间先后顺序排列
+    if [ "$WRITE_DAEMON" = true ]; then
+        PLAN="${PLAN}  • 配置 Docker 镜像源"
+        if [ "$RESTART_DOCKER" = true ]; then
+            PLAN="${PLAN}（写入可用地址，并重启 Docker）\n"
+        else
+            PLAN="${PLAN}\n"
+        fi
+    fi
     if [ "$NEED_INSTALL_GIT" = true ] || [ "$NEED_INSTALL_CURL" = true ] || [ "$NEED_INSTALL_WGET" = true ]; then
         local pkgs=""
         [ "$NEED_INSTALL_GIT" = true ] && pkgs="${pkgs} git"
@@ -613,18 +685,13 @@ generate_plan() {
         [ "$NEED_INSTALL_WGET" = true ] && pkgs="${pkgs} wget"
         PLAN="${PLAN}  • 安装必要工具:${pkgs}\n"
     fi
-    if [ "$MIRROR_STATUS" != "default_unavailable" ] && [ ${#AVAILABLE_MIRRORS[@]} -gt 0 ]; then
-        if [ "$HAS_REGISTRY_MIRRORS_KEY" = false ] || [ ${#USER_MIRRORS_AVAILABLE[@]} -eq 0 -a ${#USER_MIRRORS_UNAVAILABLE[@]} -eq 0 ] || [ "$NEED_REORDER" = true ]; then
-            PLAN="${PLAN}  • 配置 Docker 镜像加速\n"
-        fi
-    fi
     PLAN="${PLAN}  • 拉取 frpc-console 源码 (${BRANCH} 分支)\n"
-    PLAN="${PLAN}  • 构建 Docker 镜像: ${IMAGE_NAME}:${IMAGE_TAG}\n"
-    PLAN="${PLAN}  • 目标版本: ${TARGET_VERSION}\n"
     if [ "$CONTAINER_EXISTS" = true ]; then
         PLAN="${PLAN}  • 停止并删除旧容器\n"
     fi
-    PLAN="${PLAN}  • 启动 frpc-console 容器 (端口 ${PORT})"
+    PLAN="${PLAN}  • 构建 Docker 镜像: ${IMAGE_NAME}:${IMAGE_TAG}\n"
+    PLAN="${PLAN}  • 启动容器 (端口 ${PORT})\n"
+    PLAN="${PLAN}  • 写入版本文件并验证"
 }
 
 print_deployment_plan() {