openclaw config unset models.providers.<your_provider_name>

openclaw config set models.mode merge

openclaw config set models.providers '{}'

openclaw config set 'models.providers.<your_provider_name>' --json '{
  "baseUrl": "这里填你模型的 baseUrl",
  "apiKey": "这里填你模型的apiKey",
  "api": "openai-completions",
  "models": [
    {
      "id": "这里填模型id",
      "name": "这里填模型名称"
    }
  ]
}'

openclaw config set agents.defaults.model.primary <your_provider_name>/<your_model_id>

openclaw gateway restart

openclaw models status

openclaw config unset models.模型别名

openclaw config set models.mode "merge"

# 设置 API 端点地址
openclaw config set models.providers.模型别名.baseUrl "API基础URL"

# 设置 API 密钥
openclaw config set models.providers.模型别名.apiKey "API密钥"

# 设置 API 类型
openclaw config set models.providers.模型别名.api "API类型"

# 1. 先清空 models 配置
openclaw config unset models.providers.模型别名.models

# 2. 添加第一个模型
openclaw config set models.providers.模型别名.models[0].id "第一个模型ID"
openclaw config set models.providers.模型别名.models[0].name "第一个模型显示名称"

# 3. 如需添加更多模型（可选）
openclaw config set models.providers.模型别名.models[1].id "第二个模型ID"
openclaw config set models.providers.模型别名.models[1].name "第二个模型显示名称"

# 1. 清理配置
openclaw config unset models.yuanbao

# 2. 设置运行模式
openclaw config set models.mode "merge"

# 3. 配置基础信息
openclaw config set models.providers.yuanbao.baseUrl "https://bot.yuanbao.tencent.com/api/bot"
openclaw config set models.providers.yuanbao.apiKey "675628accfc4963a4a9f9c42fe98014cd29d6522717f5a79976165630c55d1bd2a8cfe4bcf821451c0455ed302eeb8d97d5fb52e8c0dd3ba07519b08d90c17845c710b4ffda5fbe7e4383d51fb64"
openclaw config set models.providers.yuanbao.api "openai-completions"

# 4. 配置模型
openclaw config unset models.providers.yuanbao.models
openclaw config set models.providers.yuanbao.models[0].id "openclaw_yuanbao_robot_model"
openclaw config set models.providers.yuanbao.models[0].name "腾讯元宝"

# 清空后重新设置多个模型
openclaw config unset models.providers.yuanbao.models

# 添加第一个模型
openclaw config set models.providers.yuanbao.models[0].id "openclaw_yuanbao_robot_model"
openclaw config set models.providers.yuanbao.models[0].name "腾讯元宝"

# 添加第二个模型
openclaw config set models.providers.yuanbao.models[1].id "yuanbao-pro"
openclaw config set models.providers.yuanbao.models[1].name "元宝Pro版"

# 分析指定容器并生成配置
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/red5d/docker-autocompose:latest \
  wp-site1 wp-site2 mysql-db

# 将输出重定向到文件
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/red5d/docker-autocompose:latest \
  wp-site1 wp-site2 mysql-db > docker-compose.yml

docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock \
  -v $(pwd):/cg/out \
  ghcr.io/compose-generator/compose-generator:latest

# 第一步：一键生成编排配置
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/red5d/docker-autocompose:latest \
  wp-site1 wp-site2 mysql-db > docker-compose.yml

# 第二步：自动生成环境变量模板
cat > .env << 'EOF'
# 自动生成的配置模板
# 请替换为实际的安全密码
DB_PASSWORD=your_secure_password_here
MYSQL_ROOT_PASSWORD=your_root_password_here
EOF

# 第三步：验证生成的配置
docker-compose config

#!/bin/bash
# 自动检测并替换latest标签为具体版本
for container in wp-site1 wp-site2 mysql-db; do
  image_name=$(docker inspect -f '{{.Config.Image}}' $container)
  if [[ "$image_name" == *:latest ]]; then
    actual_version=$(docker image inspect $image_name | grep -i version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+' | head -1)
    if [ -n "$actual_version" ]; then
      # 在docker-compose.yml中替换版本
      base_image=${image_name%:*}
      sed -i "s|image: $base_image:latest|image: $base_image:$actual_version|g" docker-compose.yml
    fi
  fi
done

# 一键生成近似的Dockerfile
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  alpine/dfimage -sV=1.36 nginx:latest

# 或使用whaler
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  pegleg/whaler nginx:latest > Dockerfile.approximate

#!/bin/bash
# migrate-docker-to-compose.sh
# 一键从现有容器迁移到编排配置

set -e

echo "🔍 开始Docker容器逆向迁移"

# 1. 使用docker-autocompose生成基础配置
echo "📦 生成docker-compose.yml..."
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/red5d/docker-autocompose:latest $(docker ps -a --format "{{.Names}}") \
  > docker-compose.yml

# 2. 生成环境变量模板
echo "🔐 创建环境变量模板..."
cat > .env.example << 'EOF'
# 自动生成的环境变量配置
# 请根据实际情况修改以下值
EOF

# 3. 生成各服务的Dockerfile（如需要）
echo "🐳 生成服务Dockerfile..."
for service in $(grep -E '^  [a-zA-Z]' docker-compose.yml | sed 's/://'); do
  image=$(grep -A5 "^  $service:" docker-compose.yml | grep "image:" | cut -d: -f2- | tr -d ' ')
  if [ -n "$image" ]; then
    echo "# 为 $service 生成Dockerfile参考"
    docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
      alpine/dfimage -sV=1.36 $image > "Dockerfile.$service" 2>/dev/null || true
  fi
done

echo "✅ 迁移完成！"
echo "📁 生成的文件："
echo "  - docker-compose.yml (主编排文件)"
echo "  - .env.example (环境变量模板)"
echo "  - Dockerfile.* (各服务构建参考)"
echo ""
echo "🚀 使用方式："
echo "  1. 编辑 .env 文件，设置实际值"
echo "  2. 运行: docker-compose up -d"
echo "  3. 验证: docker-compose ps"

# 语法验证
docker-compose config

# 测试启动（不实际运行）
docker-compose up --dry-run

# 实际测试运行
docker-compose up -d
docker-compose ps
docker-compose logs

 #!/bin/bash
# docker-compose-archaeologist-final-fixed.sh
# 最终修复版：修复序号选择和版本检测
# 版本：v2.4-final-fixed

set -e

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m'
BOLD='\033[1m'
UNDERLINE='\033[4m'

# 输出函数
error() { echo -e "${RED}✗ $1${NC}" >&2; }
success() { echo -e "${GREEN}✓ $1${NC}"; }
info() { echo -e "${BLUE}ℹ $1${NC}"; }
warning() { echo -e "${YELLOW}⚠ $1${NC}"; }
step() { echo -e "\n${CYAN}▶ $1${NC}"; }
header() { echo -e "\n${MAGENTA}▬▬▬▬▬▬▬▬▬▬ $1 ▬▬▬▬▬▬▬▬▬▬${NC}"; }

# 配置
AUTOCOMPOSE_IMAGE="ghcr.io/red5d/docker-autocompose:latest"
OUTPUT_FILE="docker-compose.yml"
TEMP_FILE="docker-compose.tmp.yml"
BACKUP_TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# 打印横幅
print_banner() {
    clear
    echo -e "${BOLD}${CYAN}"
    cat << "EOF"
╔══════════════════════════════════════════════════════════════╗
║    ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄         ║
║   ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌        ║
║   ▐░█▀▀▀▀▀▀▀▀▀ ▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀█░▌ ▀▀▀▀█░█▀▀▀▀         ║
║   ▐░▌          ▐░▌       ▐░▌▐░▌       ▐░▌     ▐░▌             ║
║   ▐░█▄▄▄▄▄▄▄▄▄ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄█░▌     ▐░▌             ║
║   ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌             ║
║    ▀▀▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀█░█▀▀ ▐░█▀▀▀▀▀▀▀█░▌     ▐░▌             ║
║             ▐░▌▐░▌     ▐░▌  ▐░▌       ▐░▌     ▐░▌             ║
║    ▄▄▄▄▄▄▄▄▄█░▌▐░▌      ▐░▌ ▐░▌       ▐░▌ ▄▄▄▄█░█▄▄▄▄         ║
║   ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░▌       ▐░▌▐░░░░░░░░░░░▌        ║
║    ▀▀▀▀▀▀▀▀▀▀▀  ▀         ▀  ▀         ▀  ▀▀▀▀▀▀▀▀▀▀▀         ║
║                                                                ║
║              Docker Compose 考古学家 v2.4                      ║
║              自动逆向生成版本化编排配置                        ║
╚══════════════════════════════════════════════════════════════╝
EOF
    echo -e "${NC}"
    
    echo -e "${YELLOW}📦 自动发现并迁移 Docker 容器到编排配置${NC}"
    echo -e "${YELLOW}🔍 支持版本号自动检测和替换${NC}"
    echo ""
}

# 检查是否安装jq
check_jq() {
    if command -v jq &> /dev/null; then
        HAS_JQ=true
        JQ_VERSION=$(jq --version | grep -oE '[0-9]+\.[0-9]+')
        success "jq $JQ_VERSION (JSON处理已启用)"
    else
        HAS_JQ=false
        warning "未检测到 jq，使用基础功能 (建议安装: sudo apt install jq)"
    fi
    echo ""
}

# 获取所有容器
get_all_containers() {
    step "扫描 Docker 容器"
    
    if [ "$HAS_JQ" = true ]; then
        CONTAINER_DATA=$(docker ps -a --format '{"Names":"{{.Names}}","Image":"{{.Image}}","Status":"{{.Status}}","State":"{{.State}}"}' | jq -s '.')
        CONTAINER_COUNT=$(echo "$CONTAINER_DATA" | jq length)
        echo "使用jq模式，找到 $CONTAINER_COUNT 个容器"
    else
        CONTAINER_LIST=$(docker ps -a --format "{{.Names}}\t{{.Image}}\t{{.Status}}")
        CONTAINER_COUNT=$(echo "$CONTAINER_LIST" | wc -l | tr -d ' ')
        echo "使用基础模式，找到 $CONTAINER_COUNT 个容器"
    fi
    
    if [ "$CONTAINER_COUNT" -eq 0 ] || [ -z "$CONTAINER_COUNT" ]; then
        error "未发现任何Docker容器"
        exit 1
    fi
    
    success "发现 $CONTAINER_COUNT 个容器"
}

# 显示容器列表
display_containers() {
    header "容器列表"
    
    echo "┌─────┬──────────────────────┬──────────────────────────┬─────────────────┐"
    echo "│ 序号 │ 容器名称              │ 镜像                    │ 状态            │"
    echo "├─────┼──────────────────────┼──────────────────────────┼─────────────────┤"
    
    if [ "$HAS_JQ" = true ]; then
        for i in $(seq 0 $((CONTAINER_COUNT-1))); do
            name=$(echo "$CONTAINER_DATA" | jq -r ".[$i].Names")
            image=$(echo "$CONTAINER_DATA" | jq -r ".[$i].Image")
            status=$(echo "$CONTAINER_DATA" | jq -r ".[$i].Status")
            
            name_display=$(printf "%-20s" "$name" | cut -c1-20)
            image_display=$(printf "%-24s" "$image" | cut -c1-24)
            status_display=$(printf "%-15s" "$status" | cut -c1-15)
            
            printf "│ %3d │ %-20s │ %-24s │ %-15s │\n" \
                $((i+1)) "$name_display" "$image_display" "$status_display"
        done
    else
        i=1
        while IFS=$'\t' read -r name image status; do
            [ -z "$name" ] && continue
            
            name_display=$(printf "%-20s" "$name" | cut -c1-20)
            image_display=$(printf "%-24s" "$image" | cut -c1-24)
            status_display=$(printf "%-15s" "$status" | cut -c1-15)
            
            printf "│ %3d │ %-20s │ %-24s │ %-15s │\n" \
                "$i" "$name_display" "$image_display" "$status_display"
            ((i++))
        done <<< "$CONTAINER_LIST"
    fi
    
    echo "└─────┴──────────────────────┴──────────────────────────┴─────────────────┘"
    echo ""
}

# 选择模式
select_mode() {
    header "选择模式"
    
    echo "请选择操作方式:"
    echo ""
    echo "  1) 📋 选择所有容器 ($CONTAINER_COUNT 个)"
    echo "  2) 🔢 选择特定容器 (支持单个、多个、范围选择)"
    echo "  3) 🎯 按状态筛选 (运行中/已停止)"
    echo "  4) 🔍 搜索容器"
    echo "  5) ❌ 退出"
    echo ""
    
    read -p "请输入选择 [1-5]: " mode
    
    case $mode in
        1)
            select_all_containers
            ;;
        2)
            select_specific_containers
            ;;
        3)
            select_by_status
            ;;
        4)
            search_containers
            ;;
        5)
            info "退出程序"
            exit 0
            ;;
        *)
            error "无效选择，使用默认模式"
            select_all_containers
            ;;
    esac
}

# 选择所有容器
select_all_containers() {
    info "选择所有容器"
    
    if [ "$HAS_JQ" = true ]; then
        SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r '.[].Names'))
    else
        SELECTED_CONTAINERS=()
        while IFS=$'\t' read -r name _; do
            [ -n "$name" ] && SELECTED_CONTAINERS+=("$name")
        done <<< "$CONTAINER_LIST"
    fi
    
    echo "已选择 ${#SELECTED_CONTAINERS[@]} 个容器"
}

# 解析范围选择
parse_range_selection() {
    local selection="$1"
    local result=()
    
    IFS=',' read -ra parts <<< "$selection"
    for part in "${parts[@]}"; do
        part=$(echo "$part" | tr -d ' ')
        
        if [[ "$part" =~ ^([0-9]+)-([0-9]+)$ ]]; then
            start=${BASH_REMATCH[1]}
            end=${BASH_REMATCH[2]}
            
            if [ "$start" -le "$end" ] && [ "$start" -ge 1 ] && [ "$end" -le "$CONTAINER_COUNT" ]; then
                for ((i=start; i<=end; i++)); do
                    result+=("$i")
                done
            else
                warning "范围 $part 无效，跳过"
            fi
        elif [[ "$part" =~ ^[0-9]+$ ]]; then
            result+=("$part")
        else
            warning "无效输入: $part，跳过"
        fi
    done
    
    echo "${result[@]}" | tr ' ' '\n' | sort -nu | tr '\n' ' '
}

# 修复：选择特定容器 - 确保不会直接退出
select_specific_containers() {
    while true; do
        info "选择特定容器"
        
        display_containers
        
        echo ""
        echo "📝 选择方式:"
        echo "  - 单个容器: 1"
        echo "  - 多个容器: 1 3 5"
        echo "  - 范围选择: 1-5"
        echo "  - 混合选择: 1,3-5,7"
        echo "  - 全部选择: all"
        echo "  - 返回菜单: back"
        echo ""
        
        read -p "请输入选择: " selection
        
        if [ "$selection" = "back" ]; then
            info "返回主菜单"
            select_mode
            return
        fi
        
        if [ "$selection" = "all" ]; then
            select_all_containers
            return
        fi
        
        if [ -z "$selection" ]; then
            error "输入为空，请重新输入"
            continue
        fi
        
        parsed_selection=$(parse_range_selection "$selection")
        
        if [ -z "$parsed_selection" ]; then
            error "无效的选择，请重新输入"
            continue
        fi
        
        SELECTED_CONTAINERS=()
        selected_count=0
        
        for num in $parsed_selection; do
            idx=$((num-1))
            
            if [ "$HAS_JQ" = true ]; then
                if [ $idx -ge 0 ] && [ $idx -lt $CONTAINER_COUNT ]; then
                    container=$(echo "$CONTAINER_DATA" | jq -r ".[$idx].Names")
                    SELECTED_CONTAINERS+=("$container")
                    ((selected_count++))
                    success "✓ 已选择: $container"
                else
                    warning "⚠ 序号 $num 无效，跳过"
                fi
            else
                container=$(echo "$CONTAINER_LIST" | sed -n "${num}p" | cut -f1)
                if [ -n "$container" ]; then
                    SELECTED_CONTAINERS+=("$container")
                    ((selected_count++))
                    success "✓ 已选择: $container"
                else
                    warning "⚠ 序号 $num 无效，跳过"
                fi
            fi
        done
        
        if [ ${#SELECTED_CONTAINERS[@]} -eq 0 ]; then
            error "未选择任何有效容器，请重新输入"
            continue
        fi
        
        success "已选择 $selected_count 个容器"
        
        # 显示选择结果
        echo ""
        echo "📋 已选择的容器:"
        for container in "${SELECTED_CONTAINERS[@]}"; do
            echo "  - $container"
        done
        echo ""
        
        # 修复：添加确认步骤，但确保不会因为确认而退出
        read -p "确认选择? [Y/重新选择(r)/返回菜单(b)]: " confirm
        
        case $confirm in
            [rR])
                info "重新选择"
                continue
                ;;
            [bB])
                info "返回主菜单"
                select_mode
                return
                ;;
            *)
                # 用户确认，继续执行
                return
                ;;
        esac
    done
}

# 按状态筛选
select_by_status() {
    while true; do
        info "按状态筛选"
        
        echo "请选择状态:"
        echo "  1) 🟢 运行中 (running)"
        echo "  2) 🔴 已停止 (exited)"
        echo "  3) 🟡 所有状态"
        echo "  4) ↩ 返回菜单"
        echo ""
        
        read -p "请输入 [1-4]: " status_choice
        
        case $status_choice in
            1) 
                status_filter="Up"
                status_display="运行中"
                ;;
            2) 
                status_filter="Exited"
                status_display="已停止"
                ;;
            3) 
                status_filter="all"
                status_display="所有状态"
                ;;
            4)
                info "返回主菜单"
                select_mode
                return
                ;;
            *) 
                error "无效选择"
                continue
                ;;
        esac
        
        SELECTED_CONTAINERS=()
        
        if [ "$status_filter" = "all" ]; then
            select_all_containers
            return
        fi
        
        if [ "$HAS_JQ" = true ]; then
            if [ "$status_filter" = "Up" ]; then
                SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r ".[] | select(.Status | startswith(\"Up\")) | .Names"))
            elif [ "$status_filter" = "Exited" ]; then
                SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r ".[] | select(.Status | startswith(\"Exited\")) | .Names"))
            fi
        else
            while IFS=$'\t' read -r name image status; do
                [ -z "$name" ] && continue
                
                if [ "$status_filter" = "Up" ] && [[ "$status" == Up* ]]; then
                    SELECTED_CONTAINERS+=("$name")
                elif [ "$status_filter" = "Exited" ] && [[ "$status" == Exited* ]]; then
                    SELECTED_CONTAINERS+=("$name")
                fi
            done <<< "$CONTAINER_LIST"
        fi
        
        if [ ${#SELECTED_CONTAINERS[@]} -eq 0 ]; then
            warning "未找到状态为 '$status_display' 的容器"
            echo ""
            read -p "是否重新选择? [Y/n] " -n 1 -r
            echo ""
            if [[ ! $REPLY =~ ^[Nn]$ ]]; then
                continue
            else
                select_mode
                return
            fi
        else
            success "找到 ${#SELECTED_CONTAINERS[@]} 个 '$status_display' 状态的容器"
            
            echo ""
            echo "📋 找到的容器:"
            for container in "${SELECTED_CONTAINERS[@]}"; do
                echo "  - $container"
            done
            echo ""
            
            read -p "确认选择? [Y/n/重新选择(r)]: " confirm
            case $confirm in
                [nN]|[rR])
                    continue
                    ;;
                *)
                    return
                    ;;
            esac
        fi
    done
}

# 搜索容器
search_containers() {
    while true; do
        info "搜索容器"
        
        echo "搜索选项:"
        echo "  1) 搜索容器名称"
        echo "  2) 搜索镜像名称"
        echo "  3) 搜索全部字段"
        echo "  4) ↩ 返回菜单"
        echo ""
        
        read -p "请选择搜索模式 [1-4]: " search_mode
        
        case $search_mode in
            1) search_type="name" ;;
            2) search_type="image" ;;
            3) search_type="all" ;;
            4) 
                info "返回主菜单"
                select_mode
                return
                ;;
            *) 
                error "无效选择"
                continue
                ;;
        esac
        
        read -p "请输入搜索关键词: " keyword
        
        if [ -z "$keyword" ]; then
            warning "搜索词为空，返回所有容器"
            select_all_containers
            return
        fi
        
        SELECTED_CONTAINERS=()
        
        if [ "$HAS_JQ" = true ]; then
            case $search_type in
                "name")
                    SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r ".[] | select(.Names | contains(\"$keyword\")) | .Names"))
                    ;;
                "image")
                    SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r ".[] | select(.Image | contains(\"$keyword\")) | .Names"))
                    ;;
                "all")
                    SELECTED_CONTAINERS=($(echo "$CONTAINER_DATA" | jq -r ".[] | select(.Names | contains(\"$keyword\")) or select(.Image | contains(\"$keyword\")) | .Names"))
                    ;;
            esac
        else
            while IFS=$'\t' read -r name image status; do
                [ -z "$name" ] && continue
                
                local match=false
                case $search_type in
                    "name")
                        [[ "$name" == *"$keyword"* ]] && match=true
                        ;;
                    "image")
                        [[ "$image" == *"$keyword"* ]] && match=true
                        ;;
                    "all")
                        [[ "$name" == *"$keyword"* ]] || [[ "$image" == *"$keyword"* ]] && match=true
                        ;;
                esac
                
                [ "$match" = true ] && SELECTED_CONTAINERS+=("$name")
            done <<< "$CONTAINER_LIST"
        fi
        
        if [ ${#SELECTED_CONTAINERS[@]} -eq 0 ]; then
            warning "未找到包含 '$keyword' 的容器"
            echo ""
            read -p "是否重新搜索? [Y/n] " -n 1 -r
            echo ""
            if [[ ! $REPLY =~ ^[Nn]$ ]]; then
                continue
            else
                select_mode
                return
            fi
        else
            success "找到 ${#SELECTED_CONTAINERS[@]} 个匹配的容器"
            
            echo ""
            echo "🔍 搜索结果:"
            for container in "${SELECTED_CONTAINERS[@]}"; do
                echo "  - $container"
            done
            echo ""
            
            read -p "确认选择? [Y/n/重新搜索(r)]: " confirm
            case $confirm in
                [nN]|[rR])
                    continue
                    ;;
                *)
                    return
                    ;;
            esac
        fi
    done
}

# 备份现有文件
backup_existing() {
    if [ -f "$OUTPUT_FILE" ]; then
        backup_file="${OUTPUT_FILE}.backup.$BACKUP_TIMESTAMP"
        cp "$OUTPUT_FILE" "$backup_file"
        info "已备份现有文件: $backup_file"
    fi
}

# 优化：使用简单的docker inspect获取版本号
get_image_version_simple() {
    local image_name="$1"
    local image_tag="$2"
    local full_image="${image_name}:${image_tag}"
    
    if ! docker image inspect "$full_image" &> /dev/null; then
        echo ""
        return
    fi
    
    # 使用简单的 docker inspect | grep -i version 方法
    local version_info=$(docker image inspect "$full_image" 2>/dev/null | \
        grep -i "version" | \
        grep -oE '[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+' | \
        head -1)
    
    if [ -n "$version_info" ]; then
        echo "$version_info"
        return
    fi
    
    # 尝试从常见的环境变量中获取
    local env_version=$(docker image inspect "$full_image" 2>/dev/null | \
        grep -oE '"VERSION="[^"]*|"NGINX_VERSION="[^"]*|"POSTGRES_VERSION="[^"]*|"MYSQL_VERSION="[^"]*|"REDIS_VERSION="[^"]*' | \
        cut -d'"' -f4 | \
        head -1)
    
    if [ -n "$env_version" ]; then
        echo "$env_version"
        return
    fi
    
    # 从创建时间推断
    local created_date=$(docker image inspect "$full_image" 2>/dev/null | \
        grep -o '"Created"[^,]*' | \
        cut -d '"' -f4 | \
        head -1 | \
        cut -d'T' -f1)
    
    if [ -n "$created_date" ]; then
        echo "$created_date" | grep -oE '^[0-9]{4}-[0-9]{2}' | tr '-' '.'
        return
    fi
    
    echo ""
}

# 替换版本号
replace_versions() {
    step "版本号考古与替换"
    
    mapfile -t IMAGE_LINES < <(grep -n -E '^\s+image:' "$TEMP_FILE" 2>/dev/null || true)
    
    if [ ${#IMAGE_LINES[@]} -eq 0 ]; then
        warning "未找到镜像定义"
        return
    fi
    
    info "发现 ${#IMAGE_LINES[@]} 个镜像"
    
    cp "$TEMP_FILE" "$OUTPUT_FILE"
    
    local replaced_count=0
    
    for line_info in "${IMAGE_LINES[@]}"; do
        line_num=$(echo "$line_info" | cut -d: -f1)
        line_content=$(echo "$line_info" | cut -d: -f2-)
        
        image_spec=$(echo "$line_content" | sed 's/^[[:space:]]*//;s/image://;s/[[:space:]]*$//;s/#.*$//')
        
        [ -z "$image_spec" ] && continue
        
        if [[ "$image_spec" == *:* ]]; then
            image_name="${image_spec%:*}"
            current_tag="${image_spec#*:}"
        else
            image_name="$image_spec"
            current_tag="latest"
        fi
        
        image_name=$(echo "$image_name" | sed "s/^['\"]//;s/['\"]$//")
        current_tag=$(echo "$current_tag" | sed "s/^['\"]//;s/['\"]$//")
        
        if [[ "$current_tag" == "latest" ]]; then
            # 使用优化后的版本检测方法
            version=$(get_image_version_simple "$image_name" "$current_tag")
            
            if [ -n "$version" ] && [ "$version" != "latest" ]; then
                # 显示调试信息
                echo -e "  ${BLUE}ℹ${NC} 检测镜像: ${image_name}:${current_tag}"
                echo -e "  ${GREEN}✓${NC} 找到版本: $version"
                
                # 替换latest为具体版本
                sed -i "s|^\(\s*image:\s*\)${image_name}:latest\b|\1${image_name}:${version}|g" "$OUTPUT_FILE"
                sed -i "s|^\(\s*image:\s*\)['\"]\?${image_name}:latest['\"]\?\b|\1\"${image_name}:${version}\"|g" "$OUTPUT_FILE"
                
                echo -e "  ${GREEN}✓${NC} 替换: ${image_name}:latest → ${image_name}:${version}"
                ((replaced_count++))
            else
                echo -e "  ${YELLOW}⚠${NC} 无法确定版本: ${image_name}:latest (保持原样)"
            fi
        else
            echo -e "  ${BLUE}ℹ${NC} 已有具体版本: ${image_name}:${current_tag}"
        fi
    done
    
    if [ $replaced_count -gt 0 ]; then
        success "版本替换完成 ($replaced_count 个镜像已更新)"
    else
        info "没有需要替换的 latest 标签"
    fi
}

# 生成Compose配置
generate_compose() {
    local containers=("$@")
    
    header "生成配置"
    
    step "验证容器"
    local valid_containers=()
    
    for container in "${containers[@]}"; do
        if docker inspect "$container" &> /dev/null; then
            valid_containers+=("$container")
            success "  ✓ $container"
        else
            error "  ✗ $container (不存在)"
        fi
    done
    
    if [ ${#valid_containers[@]} -eq 0 ]; then
        error "没有有效的容器可分析"
        exit 1
    fi
    
    backup_existing
    
    step "调用 AutoCompose"
    echo "正在分析: ${valid_containers[*]}"
    
    if ! docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
        "$AUTOCOMPOSE_IMAGE" "${valid_containers[@]}" > "$TEMP_FILE" 2>&1; then
        error "AutoCompose执行失败"
        echo "错误信息:"
        cat "$TEMP_FILE"
        exit 1
    fi
    
    if [ ! -s "$TEMP_FILE" ]; then
        error "生成的配置为空"
        exit 1
    fi
    
    success "原始配置生成完成 ($(wc -l < "$TEMP_FILE") 行)"
    
    replace_versions
    
    header "完成"
    
    echo -e "${GREEN}📁 输出文件: $OUTPUT_FILE${NC}"
    echo -e "${BLUE}📊 文件大小: $(du -h "$OUTPUT_FILE" | cut -f1)${NC}"
    echo -e "${BLUE}📈 总行数: $(wc -l < "$OUTPUT_FILE")${NC}"
    echo -e "${BLUE}📦 容器数量: ${#valid_containers[@]}${NC}"
    echo ""
    
    echo -e "${YELLOW}🔍 生成的镜像配置:${NC}"
    grep -E '^\s+image:' "$OUTPUT_FILE" 2>/dev/null | head -20 | sed 's/^/  /'
    
    echo ""
    echo -e "${CYAN}💡 使用建议:${NC}"
    echo "  1. 🔍 检查配置: vim $OUTPUT_FILE"
    echo "  2. ✅ 验证语法: docker-compose -f $OUTPUT_FILE config"
    echo "  3. 🚀 测试启动: docker-compose -f $OUTPUT_FILE up -d"
    echo "  4. 📊 查看状态: docker-compose -f $OUTPUT_FILE ps"
    echo "  5. 🛑 停止清理: docker-compose -f $OUTPUT_FILE down"
    echo ""
    
    rm -f "$TEMP_FILE"
    
    echo -e "${MAGENTA}┌──────────────────────────────────────────────────────┐${NC}"
    echo -e "${MAGENTA}│ 📁 文件位置: $(pwd)/$OUTPUT_FILE${NC}"
    echo -e "${MAGENTA}└──────────────────────────────────────────────────────┘${NC}"
}

# 修复：主函数 - 确保选择后不会直接退出
main() {
    print_banner
    
    check_jq
    
    get_all_containers
    
    display_containers
    
    select_mode
    
    # 修复：检查SELECTED_CONTAINERS是否为空
     if [ ${#SELECTED_CONTAINERS[@]} -eq 0 ]; then
        error "未选择任何容器，退出程序"
        exit 1
    fi
    
    echo ""
    echo -e "${CYAN}已选择以下 ${#SELECTED_CONTAINERS[@]} 个容器:${NC}"
    for container in "${SELECTED_CONTAINERS[@]}"; do
        echo "  - $container"
    done
    echo ""
    
    read -p "确认开始生成配置? [Y/n] " -n 1 -r
    echo ""
    if [[ $REPLY =~ ^[Nn]$ ]]; then
        info "操作取消"
        exit 0
    fi
    
    generate_compose "${SELECTED_CONTAINERS[@]}"
}

# 异常处理
trap 'echo ""; error "脚本被中断"; exit 1' INT TERM

# 运行主函数
main "$@"

chmod +x xxx.sh

# 创建并启动所有服务
docker compose up -d

# 重新构建镜像并启动
docker compose up -d --build

# 停止并删除所有容器、网络
docker compose down

# 停止容器不删除
docker compose stop

# 启动已停止的服务
docker compose start

# 重启所有服务
docker compose restart

# 进入容器 Shell
docker compose exec 服务名 sh

# 查看服务日志
docker compose logs -f 服务名

# 查看容器状态
docker compose ps

# 仅构建镜像
docker compose build

# 强制重建镜像
docker compose build --no-cache

# 拉取服务镜像
docker compose pull

# 追踪所有日志
docker compose logs -f

# 查看容器进程
docker compose top

# 验证配置语法
docker compose config

# 查看端口映射
docker compose port 服务名 端口

# 彻底清理（包括卷）
docker compose down -v

# 清理构建缓存
docker builder prune

# 前台运行调试
docker compose up

# 执行一次性命令
docker compose run --rm 服务名 命令

# 使用自定义 Compose 文件
docker compose -f docker-compose-dev.yml up

# 指定项目名称
docker compose -p 项目名 up

# 代码变更后重建
docker compose up -d --build

# 查看最近日志
docker compose logs --tail=20

# 拉取最新镜像
docker compose pull

# 滚动更新
docker compose up -d

# 彻底清理
docker compose down -v

# 从头开始
docker compose up -d --build

#!/bin/bash
# dev-restart.sh
echo "停止服务..."
docker compose stop

echo "清理旧容器..."
docker compose rm -f

echo "清理未使用的镜像..."
docker image prune -f

echo "重新构建并启动..."
docker compose up -d --build

echo "查看日志..."
docker compose logs -f

#!/bin/bash
# deploy.sh
set -e  # 出错时退出

echo "1. 拉取最新镜像..."
docker compose pull

echo "2. 备份数据库..."
docker compose exec -T db pg_dumpall -U postgres > backup_$(date +%Y%m%d_%H%M%S).sql

echo "3. 执行数据库迁移..."
docker compose run --rm web python manage.py migrate

echo "4. 重启服务..."
docker compose up -d

echo "5. 健康检查..."
sleep 30
if docker compose ps | grep -q "unhealthy"; then
  echo "❌ 服务健康检查失败"
  docker compose logs --tail=50
  exit 1
fi

echo "✅ 部署成功"

#!/bin/bash
# monitor.sh
echo "=== Docker Compose 服务状态 ==="
docker compose ps

echo -e "\n=== 资源使用情况 ==="
docker compose stats --no-stream

echo -e "\n=== 最近错误日志 ==="
docker compose logs --tail=100 2>/dev/null | grep -E "(ERROR|ERR|Error)" | tail -20

echo -e "\n=== 服务健康状态 ==="
for service in $(docker compose ps --services); do
  status=$(docker compose ps $service | tail -1 | awk '{print $4}')
  echo "$service: $status"
done

# 备份单个数据库到容器内临时目录
mysqldump -u root -p密码 数据库名 > /tmp/backup.sql

# 备份所有数据库
mysqldump -u root -p密码 --all-databases > /tmp/all_backup.sql

# 备份并压缩
mysqldump -u root -p密码 数据库名 | gzip > /tmp/backup.sql.gz

# 在宿主机执行（另一个终端窗口）
docker cp 容器名或ID:/tmp/backup.sql /宿主机/目标路径/

# 1. 容器内备份
root@容器ID:/# mysqldump -u root -p123456 mydb > /tmp/mydb_backup.sql

# 2. 宿主机复制（新终端窗口）
$ docker cp mysql-container:/tmp/mydb_backup.sql ~/backups/

# 3. 清理容器临时文件
root@容器ID:/# rm /tmp/mydb_backup.sql

# 备份单个数据库到宿主机
docker exec mysql-container mysqldump -u root -p密码 数据库名 > ~/backup.sql

# 备份所有数据库
docker exec mysql-container mysqldump -u root -p密码 --all-databases > ~/all_backup.sql

# 备份并压缩
docker exec mysql-container mysqldump -u root -p密码 数据库名 | gzip > ~/backup.sql.gz

#!/bin/bash
# MySQL 双重备份脚本
# 1. 完整备份所有数据库
# 2. 每个数据库单独备份
# 3. 保留最近3份备份

# ============ 配置区域 ============
CONTAINER_NAME="c_mysql"             # MySQL容器名
MYSQL_USER="root"                    # MySQL用户名
MYSQL_PASSWORD="songjian"            # MySQL密码
BACKUP_BASE_DIR="/root/songjian/mysql/backups"  # 备份根目录
KEEP_BACKUPS=3                       # 保留的备份份数
LOG_FILE="/root/songjian/mysql/backup-mysql.log"  # 日志文件
# ==================================

# 创建必要的目录
mkdir -p $BACKUP_BASE_DIR
mkdir -p $(dirname $LOG_FILE)

# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

# 错误处理函数
error_exit() {
    log "❌ 错误: $1"
    exit 1
}

# 获取当前时间戳
BACKUP_TIME=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="$BACKUP_BASE_DIR/$BACKUP_TIME"

log "=========================================="
log "开始 MySQL 双重备份"
log "备份时间: $BACKUP_TIME"
log "备份目录: $BACKUP_DIR"
log "容器名称: $CONTAINER_NAME"
log "备份路径: $BACKUP_BASE_DIR"

# 检查容器是否运行
CONTAINER_STATUS=$(docker ps --filter "name=$CONTAINER_NAME" --format "{{.Names}}")

if [ -z "$CONTAINER_STATUS" ]; then
    error_exit "容器 ${CONTAINER_NAME} 未运行！"
else
    log "✅ 容器状态: 运行中 ($CONTAINER_NAME)"
fi

# 创建本次备份目录
mkdir -p $BACKUP_DIR/all_databases
mkdir -p $BACKUP_DIR/separate_databases
mkdir -p $BACKUP_DIR/logs

# 1. 备份所有数据库（完整备份）
log "1. 开始完整备份所有数据库..."
ALL_BACKUP_FILE="$BACKUP_DIR/all_databases/full_backup.sql.gz"

# 测试 MySQL 连接
log "测试 MySQL 连接..."
if ! docker exec $CONTAINER_NAME mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1" >/dev/null 2>&1; then
    error_exit "无法连接到 MySQL 数据库，请检查用户名和密码"
else
    log "✅ MySQL 连接测试成功"
fi

# 执行完整备份
docker exec $CONTAINER_NAME mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD \
  --all-databases \
  --single-transaction \
  --routines \
  --events \
  --triggers \
  --set-gtid-purged=OFF 2>> "$BACKUP_DIR/logs/full_backup.log" | gzip > $ALL_BACKUP_FILE

if [ $? -eq 0 ] && [ -s $ALL_BACKUP_FILE ]; then
    SIZE=$(du -h $ALL_BACKUP_FILE | cut -f1)
    log "   ✅ 完整备份成功: $(basename $ALL_BACKUP_FILE) ($SIZE)"
else
    # 尝试不使用 --set-gtid-purged 参数
    log "⚠️ 第一次备份失败，尝试不使用 GTID 参数..."
    docker exec $CONTAINER_NAME mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD \
      --all-databases \
      --single-transaction \
      --routines \
      --events \
      --triggers 2>> "$BACKUP_DIR/logs/full_backup_alt.log" | gzip > $ALL_BACKUP_FILE

    if [ $? -eq 0 ] && [ -s $ALL_BACKUP_FILE ]; then
        SIZE=$(du -h $ALL_BACKUP_FILE | cut -f1)
        log "   ✅ 完整备份成功(备选方案): $(basename $ALL_BACKUP_FILE) ($SIZE)"
    else
        error_exit "完整备份失败！"
    fi
fi

# 2. 获取所有数据库列表
log "2. 获取数据库列表..."
DATABASES=$(docker exec $CONTAINER_NAME mysql -u$MYSQL_USER -p$MYSQL_PASSWORD \
  --skip-column-names \
  -e "SHOW DATABASES;" 2>> "$BACKUP_DIR/logs/db_list.log")

if [ $? -ne 0 ]; then
    error_exit "获取数据库列表失败！"
fi

# 过滤掉系统数据库
FILTERED_DATABASES=""
for DB in $DATABASES; do
    case $DB in
        information_schema|performance_schema|sys|mysql)
            log "   跳过系统数据库: $DB"
            ;;
        *)
            FILTERED_DATABASES="$FILTERED_DATABASES $DB"
            ;;
    esac
done

# 重新赋值
DATABASES=$FILTERED_DATABASES
DB_COUNT=$(echo "$DATABASES" | wc -w)

log "   找到 $DB_COUNT 个用户数据库需要单独备份"

# 如果没有数据库，只备份完整备份
if [ $DB_COUNT -eq 0 ]; then
    log "⚠️ 没有找到用户数据库，只保留完整备份"

    # 创建备份摘要
    cat > "$BACKUP_DIR/backup_summary.txt" << EOF
备份摘要
========
备份时间: $(date)
备份编号: $BACKUP_TIME
备份目录: $BACKUP_DIR
容器名称: $CONTAINER_NAME

备份内容:
1. 完整备份: $ALL_BACKUP_FILE
   大小: $(du -h $ALL_BACKUP_FILE | cut -f1)

2. 单独数据库备份: 0 个 (没有找到用户数据库)

备份统计:
   数据库总数: 0
   完整备份: 成功
   单独备份: 跳过
EOF

    # 清理旧备份
    cleanup_old_backups
    exit 0
fi

log "   需要备份的数据库: $DATABASES"

# 3. 逐个备份每个数据库
SUCCESS_COUNT=0
FAIL_COUNT=0
FAILED_DBS=""
log "3. 开始逐个数据库备份..."

for DB in $DATABASES; do
    log "   备份数据库: $DB"
    DB_BACKUP_FILE="$BACKUP_DIR/separate_databases/${DB}.sql.gz"

    docker exec $CONTAINER_NAME mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD \
      --single-transaction \
      --routines \
      --events \
      --triggers \
      $DB 2>> "$BACKUP_DIR/logs/${DB}.log" | gzip > $DB_BACKUP_FILE

    if [ $? -eq 0 ] && [ -s $DB_BACKUP_FILE ]; then
        SIZE=$(du -h $DB_BACKUP_FILE | cut -f1)
        log "      ✅ 成功 ($SIZE)"
        ((SUCCESS_COUNT++))
    else
        log "      ❌ 失败，尝试简单备份..."
        # 尝试简化备份
        docker exec $CONTAINER_NAME mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD \
          $DB 2>> "$BACKUP_DIR/logs/${DB}_simple.log" | gzip > $DB_BACKUP_FILE

        if [ $? -eq 0 ] && [ -s $DB_BACKUP_FILE ]; then
            SIZE=$(du -h $DB_BACKUP_FILE | cut -f1)
            log "      ✅ 成功(简单模式) ($SIZE)"
            ((SUCCESS_COUNT++))
        else
            log "      ❌❌ 备份失败"
            rm -f $DB_BACKUP_FILE
            FAILED_DBS="$FAILED_DBS $DB"
            ((FAIL_COUNT++))
        fi
    fi
done

log "   数据库单独备份完成: 成功 $SUCCESS_COUNT 个, 失败 $FAIL_COUNT 个"
if [ $FAIL_COUNT -gt 0 ]; then
    log "   失败的数据库: $FAILED_DBS"
fi

# 4. 创建备份摘要
log "4. 生成备份摘要..."
SUMMARY_FILE="$BACKUP_DIR/backup_summary.txt"
cat > $SUMMARY_FILE << EOF
备份摘要
========
备份时间: $(date)
备份编号: $BACKUP_TIME
备份目录: $BACKUP_DIR
容器名称: $CONTAINER_NAME
MySQL 用户: $MYSQL_USER

备份内容:
1. 完整备份: $ALL_BACKUP_FILE
   大小: $(du -h $ALL_BACKUP_FILE | cut -f1)

2. 单独数据库备份 ($SUCCESS_COUNT 个):
EOF

# 添加每个数据库的备份信息
for DB in $DATABASES; do
    FILE="$BACKUP_DIR/separate_databases/${DB}.sql.gz"
    if [ -f "$FILE" ]; then
        SIZE=$(du -h "$FILE" 2>/dev/null | cut -f1 || echo "未知")
        echo "   - $DB: $SIZE" >> $SUMMARY_FILE
    fi
done

cat >> $SUMMARY_FILE << EOF

备份统计:
   数据库总数: $DB_COUNT
   成功备份: $SUCCESS_COUNT
   备份失败: $FAIL_COUNT
EOF

if [ -n "$FAILED_DBS" ]; then
    echo "   失败列表: $FAILED_DBS" >> $SUMMARY_FILE
fi

cat >> $SUMMARY_FILE << EOF
   日志文件: $BACKUP_DIR/logs/

生成时间: $(date)
EOF

# 5. 清理旧备份函数
cleanup_old_backups() {
    log "5. 清理旧备份（保留最近 $KEEP_BACKUPS 份）..."
    BACKUP_LIST=($(ls -dt $BACKUP_BASE_DIR/20* 2>/dev/null))
    BACKUP_COUNT=${#BACKUP_LIST[@]}

    if [ $BACKUP_COUNT -gt $KEEP_BACKUPS ]; then
        TO_DELETE_COUNT=$((BACKUP_COUNT - KEEP_BACKUPS))
        log "   发现 $BACKUP_COUNT 份备份，需要删除 $TO_DELETE_COUNT 份旧备份"

        for ((i=KEEP_BACKUPS; i<BACKUP_COUNT; i++)); do
            OLD_BACKUP=${BACKUP_LIST[$i]}
            OLD_BACKUP_NAME=$(basename "$OLD_BACKUP")
            log "   删除旧备份: $OLD_BACKUP_NAME"
            rm -rf "$OLD_BACKUP"

            # 记录删除操作
            echo "删除备份: $OLD_BACKUP_NAME ($(date))" >> "$BACKUP_DIR/logs/cleanup.log"
        done
    else
        log "   当前有 $BACKUP_COUNT 份备份，无需清理（最多保留 $KEEP_BACKUPS 份）"
    fi
}

# 执行清理
cleanup_old_backups

# 6. 计算总大小
TOTAL_SIZE=$(du -sh $BACKUP_DIR 2>/dev/null | cut -f1 || echo "0B")
REMAINING_SIZE=$(du -sh $BACKUP_BASE_DIR 2>/dev/null | cut -f1 || echo "0B")
BACKUP_LIST_CURRENT=($(ls -dt $BACKUP_BASE_DIR/20* 2>/dev/null))
CURRENT_BACKUP_COUNT=${#BACKUP_LIST_CURRENT[@]}

log "6. 备份完成统计"
log "   本次备份大小: $TOTAL_SIZE"
log "   总备份占用: $REMAINING_SIZE"
log "   当前保留备份: $CURRENT_BACKUP_COUNT 份"
log "   备份目录: $BACKUP_BASE_DIR"
log "   备份日志: $LOG_FILE"

# 生成最终报告
log "=========================================="
log "✅ MySQL 双重备份完成！"
log "   备份编号: $BACKUP_TIME"
log "   完整备份: $(basename $ALL_BACKUP_FILE)"
log "   单独备份: $SUCCESS_COUNT 个数据库"
log "   保留备份: $CURRENT_BACKUP_COUNT/$KEEP_BACKUPS 份"

# 输出摘要
echo ""
echo "===== 备份摘要 ====="
cat $SUMMARY_FILE