#!/bin/bash

# 检查必要的环境变量
if [ -z "$G_NAME" ] || [ -z "$G_TOKEN" ]; then
    echo "缺少必要的环境变量 G_NAME 或 G_TOKEN"
    exit 1
fi

# 使用独立的工作目录，避免与配置目录冲突
WORK_DIR="/tmp/mcp_sync_work"
GITHUB_DATA_DIR="$WORK_DIR/github_data"

# 从 WebDAV 恢复配置的函数
restore_from_webdav() {
    if [ -z "$WEBDAV_URL" ] || [ -z "$WEBDAV_USERNAME" ] || [ -z "$WEBDAV_PASSWORD" ]; then
        echo "WebDAV 环境变量缺失，无法从 WebDAV 恢复。"
        return 1
    fi
    
    echo "正在从 WebDAV 恢复配置文件..."
    
    # 创建临时恢复目录
    RESTORE_DIR="$WORK_DIR/webdav_restore"
    mkdir -p "$RESTORE_DIR"
    
    # 获取WebDAV上所有备份文件列表
    echo "获取 WebDAV 备份文件列表..."
    
    # 尝试使用PROPFIND方法获取目录列表（WebDAV标准方法）
    RAW_RESPONSE=$(curl -s -X PROPFIND \
        --user "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" \
        -H "Depth: 1" \
        -H "Content-Type: text/xml" \
        -d '<?xml version="1.0" encoding="utf-8"?><propfind xmlns="DAV:"><prop><displayname/></prop></propfind>' \
        "$WEBDAV_URL/")
    
    # 如果PROPFIND失败，尝试简单的GET请求
    if [ -z "$RAW_RESPONSE" ] || echo "$RAW_RESPONSE" | grep -q "Method Not Allowed"; then
        RAW_RESPONSE=$(curl -s --user "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" "$WEBDAV_URL/")
    fi
    
    # 多种匹配方式
    # 方式1: 从XML响应中提取文件名
    BACKUP_LIST1=$(echo "$RAW_RESPONSE" | grep -oE '<D:displayname[^>]*>[^<]*mcp_backup_[0-9]+_[0-9]+\.tar\.gz[^<]*</D:displayname>' | sed 's/<[^>]*>//g')
    
    # 方式2: 从href属性中提取
    BACKUP_LIST2=$(echo "$RAW_RESPONSE" | grep -oE 'href="[^"]*mcp_backup_[0-9]+_[0-9]+\.tar\.gz[^"]*"' | sed 's/.*href="[^"]*\///g' | sed 's/".*//g')
    
    # 方式3: 简单文本匹配
    BACKUP_LIST3=$(echo "$RAW_RESPONSE" | grep -oE 'mcp_backup_[0-9]+_[0-9]+\.tar\.gz')
    
    # 合并所有结果
    BACKUP_LIST=$(printf "%s\n%s\n%s\n" "$BACKUP_LIST1" "$BACKUP_LIST2" "$BACKUP_LIST3" | grep -v '^$' | sort -u | sort -r)
    
    if [ -z "$BACKUP_LIST" ]; then
        echo "未找到任何备份文件"
        rm -rf "$RESTORE_DIR"
        return 1
    fi
    
    echo "找到以下备份文件："
    echo "$BACKUP_LIST" | head -5 | while read file; do echo "  - $file"; done
    if [ $(echo "$BACKUP_LIST" | wc -l) -gt 5 ]; then
        echo "  ... 等共 $(echo "$BACKUP_LIST" | wc -l) 个文件"
    fi
    
    # 尝试下载最新的备份文件
    LATEST_BACKUP=$(echo "$BACKUP_LIST" | head -1)
    echo "尝试下载最新备份: $LATEST_BACKUP"
    
    if curl -f --user "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" "$WEBDAV_URL/$LATEST_BACKUP" -o "$RESTORE_DIR/$LATEST_BACKUP" 2>/dev/null; then
        echo "下载备份成功: $LATEST_BACKUP"
        
        # 解压缩备份文件
        cd "$RESTORE_DIR"
        tar -xzf "$LATEST_BACKUP" && {
            echo "解压缩备份文件成功"
            
            # 恢复配置文件
            if [ -d "config" ] && [ "$(ls -A config 2>/dev/null)" ]; then
                echo "恢复 config 目录..."
                mkdir -p /mcp-proxy-server/config
                cp -r config/* /mcp-proxy-server/config/
                echo "config 目录恢复成功"
            else
                echo "备份中没有 config 目录或目录为空"
            fi
            
            if [ -d "tools" ] && [ "$(ls -A tools 2>/dev/null)" ]; then
                echo "恢复 tools 目录..."
                mkdir -p /tools
                cp -r tools/* /tools/
                echo "tools 目录恢复成功"
            else
                echo "备份中没有 tools 目录或目录为空"
            fi
            
            echo "从 WebDAV 恢复配置文件完成"
        } || {
            echo "解压缩备份文件失败"
        }
        cd - > /dev/null
    else
        echo "下载最新备份失败，尝试其他备份文件..."
        
        # 尝试前3个备份文件
        SUCCESS=0
        for backup_file in $(echo "$BACKUP_LIST" | head -3 | tail -n +2); do
            echo "尝试下载: $backup_file"
            if curl -f --user "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" "$WEBDAV_URL/$backup_file" -o "$RESTORE_DIR/$backup_file" 2>/dev/null; then
                echo "下载成功，开始解压..."
                cd "$RESTORE_DIR"
                if tar -xzf "$backup_file"; then
                    echo "解压成功，恢复文件..."
                    
                    # 恢复配置文件
                    if [ -d "config" ] && [ "$(ls -A config 2>/dev/null)" ]; then
                        mkdir -p /mcp-proxy-server/config
                        cp -r config/* /mcp-proxy-server/config/
                        echo "config 目录恢复成功"
                    fi
                    
                    if [ -d "tools" ] && [ "$(ls -A tools 2>/dev/null)" ]; then
                        mkdir -p /tools
                        cp -r tools/* /tools/
                        echo "tools 目录恢复成功"
                    fi
                    
                    SUCCESS=1
                    break
                fi
                cd - > /dev/null
            fi
        done
        
        if [ "$SUCCESS" = "0" ]; then
            echo "无法下载任何可用的备份文件"
        fi
    fi
    
    # 清理临时目录
    rm -rf "$RESTORE_DIR"
    return 0
}

# 解析仓库名和用户名
IFS='/' read -r GITHUB_USER GITHUB_REPO <<< "$G_NAME"

# 构建 GitHub 仓库的克隆 URL，包含令牌
REPO_URL="https://${G_TOKEN}@github.com/${G_NAME}.git"
mkdir -p "$GITHUB_DATA_DIR"

# 克隆仓库
echo "正在克隆仓库到 $GITHUB_DATA_DIR ……"
git clone "$REPO_URL" "$GITHUB_DATA_DIR" || {
    echo "克隆失败，请检查 G_NAME 和 G_TOKEN 是否正确。"
    exit 1
}

# 检查命令行参数，支持选择恢复源
RESTORE_SOURCE="auto"  # 默认自动选择
if [ "$1" = "--restore-webdav" ]; then
    RESTORE_SOURCE="webdav"
elif [ "$1" = "--restore-github" ]; then
    RESTORE_SOURCE="github"
elif [ "$1" = "--restore-only" ]; then
    RESTORE_SOURCE="$2"
    if [ "$RESTORE_SOURCE" = "webdav" ]; then
        restore_from_webdav
        exit 0
    elif [ "$RESTORE_SOURCE" = "github" ]; then
        RESTORE_SOURCE="github"
    else
        echo "用法: $0 --restore-only [github|webdav]"
        exit 1
    fi
fi

# 恢复逻辑
if [ "$RESTORE_SOURCE" = "webdav" ]; then
    # 仅从 WebDAV 恢复
    restore_from_webdav
elif [ "$RESTORE_SOURCE" = "github" ] || [ "$RESTORE_SOURCE" = "auto" ]; then
    # 从 GitHub 恢复（根据环境变量决定是否包含tools）
    GITHUB_RESTORED=0
    GITHUB_TOOLS_RESTORED=0
    
    if [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
        echo "从 GitHub 恢复配置（config 和 tools 目录）..."
    else
        echo "从 GitHub 恢复配置（仅 config 目录）..."
    fi
    
    # 检查并恢复 config 目录
    if [ -d "$GITHUB_DATA_DIR/config" ] && [ "$(ls -A $GITHUB_DATA_DIR/config 2>/dev/null)" ]; then
        echo "从 GitHub 恢复 config 目录..."
        mkdir -p /mcp-proxy-server/config
        cp -r "$GITHUB_DATA_DIR/config"/* /mcp-proxy-server/config/
        echo "GitHub: config 目录恢复成功"
        GITHUB_RESTORED=1
    else
        echo "GitHub 仓库中没有 config 目录或目录为空"
    fi
    
    # 检查并恢复 tools 目录（仅当环境变量允许时）
    if [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
        if [ -d "$GITHUB_DATA_DIR/tools" ] && [ "$(ls -A $GITHUB_DATA_DIR/tools 2>/dev/null)" ]; then
            echo "从 GitHub 恢复 tools 目录..."
            mkdir -p /tools
            cp -r "$GITHUB_DATA_DIR/tools"/* /tools/
            echo "GitHub: tools 目录恢复成功"
            GITHUB_TOOLS_RESTORED=1
        else
            echo "GitHub 仓库中没有 tools 目录或目录为空"
        fi
    else
        echo "跳过 tools 目录恢复（由 GITHUB_BACKUP_TOOLS=false 控制）"
        # 当 GITHUB_BACKUP_TOOLS=false 时，强制从 WebDAV 恢复 tools
        GITHUB_TOOLS_RESTORED=0
    fi
    
    # auto 模式的补充恢复逻辑
    if [ "$RESTORE_SOURCE" = "auto" ]; then
        if [ "$GITHUB_RESTORED" = "0" ]; then
            # GitHub完全没有恢复任何内容，尝试完整WebDAV恢复
            echo "GitHub 中没有找到任何配置，尝试从 WebDAV 恢复..."
            restore_from_webdav || echo "WebDAV 恢复失败，将在同步时重新备份"
        elif [ "$GITHUB_TOOLS_RESTORED" = "0" ]; then
            # GitHub恢复了config但没有tools，或者禁用了GitHub tools备份，从WebDAV恢复tools
            if [ "$GITHUB_BACKUP_TOOLS" = "false" ]; then
                echo "GitHub tools 备份已禁用，从 WebDAV 恢复 tools 目录..."
            else
                echo "GitHub 中没有 tools 目录，尝试从 WebDAV 补充恢复..."
            fi
            restore_from_webdav || echo "WebDAV 恢复失败"
        fi
    elif [ "$GITHUB_RESTORED" = "1" ]; then
        echo "从 GitHub 恢复配置完成"
    else
        echo "GitHub 中没有可恢复的配置"
    fi
fi

# 如果是仅恢复模式，则退出
if [ "$1" = "--restore-only" ]; then
    exit 0
fi

# 定义同步函数
sync_data() {
    while true; do
        # 1. 同步到 GitHub
        echo "正在开始同步"
        # 进入仓库目录
        cd "$GITHUB_DATA_DIR"
        # 配置 Git 用户信息
        git config user.name "AutoSync Bot"
        git config user.email "autosync@bot.com"

        # 确保在正确的分支
        git checkout main || git checkout master

        # 复制最新的配置文件
        GITHUB_BACKUP_TOOLS=${GITHUB_BACKUP_TOOLS:-true}
        
        if [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
            echo "检查配置文件变化（GitHub 备份 config 和 tools 目录）..."
        else
            echo "检查配置文件变化（GitHub 仅备份 config 目录）..."
        fi
        
        # 先从GitHub拉取最新状态，实现双向同步
        echo "从 GitHub 拉取最新状态..."
        git fetch origin
        
        # 检查是否有远程更新
        LOCAL_COMMIT=$(git rev-parse HEAD)
        REMOTE_COMMIT=$(git rev-parse origin/$(git branch --show-current))
        
        if [ "$LOCAL_COMMIT" != "$REMOTE_COMMIT" ]; then
            echo "检测到 GitHub 有更新，正在同步..."
            
            # 保存本地文件状态
            TEMP_BACKUP_DIR="$WORK_DIR/local_backup"
            rm -rf "$TEMP_BACKUP_DIR"
            mkdir -p "$TEMP_BACKUP_DIR"
            
            # 备份本地的config和tools到临时目录
            if [ -d "/mcp-proxy-server/config" ]; then
                cp -r "/mcp-proxy-server/config" "$TEMP_BACKUP_DIR/" 2>/dev/null || true
            fi
            if [ -d "/tools" ] && [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
                cp -r "/tools" "$TEMP_BACKUP_DIR/" 2>/dev/null || true
            fi
            
            # 执行硬重置到远程状态
            git reset --hard origin/$(git branch --show-current)
            
            # 从GitHub更新本地文件
            if [ -d "./config" ] && [ "$(ls -A ./config 2>/dev/null)" ]; then
                echo "从 GitHub 更新 config 目录..."
                mkdir -p /mcp-proxy-server/config
                cp -r ./config/* /mcp-proxy-server/config/
            else
                # 如果GitHub中没有config目录，清空本地config
                echo "GitHub 中没有 config 目录，清空本地 config..."
                rm -rf /mcp-proxy-server/config/*
            fi
            
            # 根据GITHUB_BACKUP_TOOLS设置处理tools目录
            if [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
                if [ -d "./tools" ] && [ "$(ls -A ./tools 2>/dev/null)" ]; then
                    echo "从 GitHub 更新 tools 目录..."
                    mkdir -p /tools
                    rm -rf /tools/*  # 清空现有tools
                    cp -r ./tools/* /tools/
                else
                    # 如果GitHub中没有tools目录，清空本地tools
                    echo "GitHub 中没有 tools 目录，清空本地 tools..."
                    rm -rf /tools/*
                fi
            else
                # 如果禁用了GitHub tools备份，从WebDAV恢复tools
                echo "GitHub tools 备份已禁用，从 WebDAV 恢复 tools 目录..."
                restore_from_webdav || echo "WebDAV 恢复失败"
            fi
            
            echo "GitHub 同步完成"
            
            # 清理临时备份
            rm -rf "$TEMP_BACKUP_DIR"
        else
            echo "GitHub 状态已是最新"
        fi
        
        # 同步 config 目录到 GitHub
        if [ -d "/mcp-proxy-server/config" ]; then
            # 检查是否有非工作目录的文件
            CONFIG_FILES=$(ls -A /mcp-proxy-server/config 2>/dev/null | grep -v -E '(github_data|temp_backup|webdav_restore)' || true)
            
            if [ -n "$CONFIG_FILES" ]; then
                # 使用 cp 代替 rsync，逐步复制，排除工作目录
                for item in /mcp-proxy-server/config/*; do
                    if [ -e "$item" ]; then
                        BASENAME=$(basename "$item")
                        case "$BASENAME" in
                            github_data|temp_backup|webdav_restore)
                                ;;
                            *)
                                if [ -d "$item" ]; then
                                    cp -r "$item" ./config/ 2>/dev/null
                                else
                                    cp "$item" ./config/ 2>/dev/null
                                fi
                                ;;
                        esac
                    fi
                done
            fi
        fi
        
        # 同步 tools 目录到 GitHub（处理多个MCP仓库）
        if [ "$GITHUB_BACKUP_TOOLS" = "true" ] && [ -d "/tools" ] && [ "$(ls -A /tools 2>/dev/null)" ]; then
            # 清空目标目录
            rm -rf ./tools/*
            
            echo "处理 tools 目录中的 MCP 工具..."
            
            PROCESSED_COUNT=0
            
            # 逐个处理 tools 目录下的MCP工具
            for item in /tools/*; do
                if [ -e "$item" ]; then
                    BASENAME=$(basename "$item")
                    
                    if [ -d "$item" ]; then
                        echo "  处理 MCP 工具: $BASENAME"
                        
                        # 检查是否是Git仓库
                        if [ -d "$item/.git" ]; then
                            echo "    → 检测到Git仓库，排除.git目录"
                        fi
                        
                        # 创建目标目录
                        mkdir -p "./tools/$BASENAME"
                        
                        # 复制目录内容
                        if [ "$(ls -A "$item" 2>/dev/null)" ]; then
                            # 复制所有普通文件和目录（排除.git）
                            for subitem in "$item"/*; do
                                if [ -e "$subitem" ] && [ "$(basename "$subitem")" != ".git" ]; then
                                    cp -r "$subitem" "./tools/$BASENAME/" 2>/dev/null || true
                                fi
                            done
                            
                            # 复制隐藏文件，但排除 .git 目录
                            for hidden in "$item"/.[!.]*; do
                                if [ -e "$hidden" ] && [ "$(basename "$hidden")" != ".git" ]; then
                                    cp -r "$hidden" "./tools/$BASENAME/" 2>/dev/null || true
                                fi
                            done
                            
                            # 检查复制结果
                            COPIED_FILES=$(ls -A "./tools/$BASENAME" 2>/dev/null | wc -l)
                            echo "    → 已复制 $COPIED_FILES 个文件/目录"
                        else
                            # 空目录创建 .gitkeep
                            touch "./tools/$BASENAME/.gitkeep"
                            echo "    → 空目录，已创建 .gitkeep"
                        fi
                        
                        PROCESSED_COUNT=$((PROCESSED_COUNT + 1))
                    else
                        # 直接复制文件
                        echo "  复制文件: $BASENAME"
                        cp "$item" "./tools/" 2>/dev/null || true
                        PROCESSED_COUNT=$((PROCESSED_COUNT + 1))
                    fi
                fi
            done
            
            # 显示处理结果摘要
            if [ "$PROCESSED_COUNT" -gt 0 ]; then
                echo "总计处理 $PROCESSED_COUNT 个 MCP 工具"
            fi
        elif [ "$GITHUB_BACKUP_TOOLS" = "false" ]; then
            echo "跳过 tools 目录（由 GITHUB_BACKUP_TOOLS=false 控制）"
        fi
        
        # 检查是否有变化
        CONFIG_CHANGED=0
        TOOLS_CHANGED=0
        
        # 检查 config 目录变化（用于 GitHub 备份）
        if [[ -n $(git status -s) ]]; then
            CONFIG_CHANGED=1
        fi
        
        # 检查 tools 目录变化（用于 WebDAV 备份）
        TOOLS_LAST_CHECK_FILE="$WORK_DIR/tools_last_check"
        if [ -d "/tools" ] && [ "$(ls -A /tools 2>/dev/null)" ]; then
            # 获取 tools 目录的最新修改时间
            CURRENT_TOOLS_TIME=$(find /tools -type f -exec stat -c %Y {} \; 2>/dev/null | sort -n | tail -1)
            
            if [ -f "$TOOLS_LAST_CHECK_FILE" ]; then
                LAST_TOOLS_TIME=$(cat "$TOOLS_LAST_CHECK_FILE" 2>/dev/null || echo "0")
                if [ "$CURRENT_TOOLS_TIME" != "$LAST_TOOLS_TIME" ]; then
                    TOOLS_CHANGED=1
                fi
            else
                TOOLS_CHANGED=1
            fi
            
            # 更新检查时间戳
            echo "$CURRENT_TOOLS_TIME" > "$TOOLS_LAST_CHECK_FILE"
        fi
        
        # 根据变化情况执行备份
        if [ "$CONFIG_CHANGED" = "1" ] || [ "$TOOLS_CHANGED" = "1" ]; then
            echo "检测到文件变化，开始备份..."
            
            # GitHub 备份（仅当 config 有变化时）
            if [ "$CONFIG_CHANGED" = "1" ]; then
                if [ "$GITHUB_BACKUP_TOOLS" = "true" ]; then
                    echo "→ GitHub 备份 (config + tools)"
                    git add config/ tools/
                    git commit -m "Auto sync config and tools $(date '+%Y-%m-%d %H:%M:%S')"
                else
                    echo "→ GitHub 备份 (config only)"
                    git add config/
                    git commit -m "Auto sync config $(date '+%Y-%m-%d %H:%M:%S')"
                fi
                git push origin HEAD >/dev/null 2>&1 && echo "  ✓ 推送成功" || echo "  ✗ 推送失败"
            fi
            
            # WebDAV 备份（当 config 或 tools 有变化时）
            if [ -z "$WEBDAV_URL" ] || [ -z "$WEBDAV_USERNAME" ] || [ -z "$WEBDAV_PASSWORD" ]; then
                echo "  WebDAV 环境变量缺失，跳过"
            else
                echo "→ WebDAV 备份 (config + tools)"
                # 使用时间戳（年月日时分），每次同步都创建新备份
                FILENAME="mcp_backup_$(date +'%Y%m%d_%H%M').tar.gz"
                
                # 创建临时备份压缩包（使用独立目录）
                TEMP_DIR="$WORK_DIR/temp_backup"
                rm -rf "$TEMP_DIR"
                mkdir -p "$TEMP_DIR"
                
                # 复制要备份的目录到临时目录（WebDAV 备份包含 config 和 tools）
                BACKUP_CREATED=0
                
                if [ -d "/mcp-proxy-server/config" ]; then
                    CONFIG_FILES=$(ls -A /mcp-proxy-server/config 2>/dev/null | grep -v -E '(github_data|temp_backup|webdav_restore)' || true)
                    
                    if [ -n "$CONFIG_FILES" ]; then
                        mkdir -p "$TEMP_DIR/config"
                        for item in /mcp-proxy-server/config/*; do
                            if [ -e "$item" ]; then
                                BASENAME=$(basename "$item")
                                case "$BASENAME" in
                                    github_data|temp_backup|webdav_restore)
                                        ;;
                                    *)
                                        if [ -d "$item" ]; then
                                            cp -r "$item" "$TEMP_DIR/config/" 2>/dev/null && BACKUP_CREATED=1
                                        else
                                            cp "$item" "$TEMP_DIR/config/" 2>/dev/null && BACKUP_CREATED=1
                                        fi
                                        ;;
                                esac
                            fi
                        done
                    fi
                fi
                
                if [ -d "/tools" ] && [ "$(ls -A /tools 2>/dev/null)" ]; then
                    mkdir -p "$TEMP_DIR/tools"
                    for item in /tools/*; do
                        if [ -e "$item" ]; then
                            BASENAME=$(basename "$item")
                            if [ -d "$item" ]; then
                                mkdir -p "$TEMP_DIR/tools/$BASENAME"
                                if [ "$(ls -A "$item" 2>/dev/null)" ]; then
                                    cp -r "$item"/* "$TEMP_DIR/tools/$BASENAME/" 2>/dev/null && BACKUP_CREATED=1
                                    cp -r "$item"/.[!.]* "$TEMP_DIR/tools/$BASENAME/" 2>/dev/null || true
                                else
                                    touch "$TEMP_DIR/tools/$BASENAME/.gitkeep"
                                    BACKUP_CREATED=1
                                fi
                            else
                                cp "$item" "$TEMP_DIR/tools/" 2>/dev/null && BACKUP_CREATED=1
                            fi
                        fi
                    done
                fi
                
                # 创建压缩包
                if [ "$BACKUP_CREATED" = "1" ] && [ "$(ls -A $TEMP_DIR)" ]; then
                    (cd "$TEMP_DIR" && tar -czf "../$FILENAME" .)
                    
                    curl -T "$WORK_DIR/$FILENAME" --user "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" "$WEBDAV_URL/$FILENAME" >/dev/null 2>&1 && echo "  ✓ 上传成功" || echo "  ✗ 上传失败"
                    rm -f "$WORK_DIR/$FILENAME"
                else
                    echo "  ✗ 无文件可备份"
                fi
                
                rm -rf "$TEMP_DIR"
            fi
            
            echo "备份完成"

        else
            echo "无文件变化，跳过备份"
        fi
        
        # 返回上级目录
        cd - > /dev/null
        
        # 3. 等待统一的时间间隔
        SYNC_INTERVAL=${SYNC_INTERVAL:-7200}  # 默认间隔时间为 7200 秒
        echo "等待 ${SYNC_INTERVAL} 秒后进行下一次检查..."
        sleep $SYNC_INTERVAL

    done
}

# 后台启动同步进程
sync_data &

echo "同步进程已在后台启动 (PID: $!)"
echo "现在启动 MCP Proxy 主程序..."

# 启动原始的 MCP Proxy 程序
echo "准备启动 MCP Proxy，端口: ${PORT:-7860}，主机: ${HOST:-0.0.0.0}"

if [ -f build/sse.js ]; then
    echo "启动: node build/sse.js"
    PORT=${PORT:-7860} HOST=${HOST:-0.0.0.0} exec node build/sse.js
elif [ -f /app/build/sse.js ]; then
    echo "启动: node /app/build/sse.js"
    PORT=${PORT:-7860} HOST=${HOST:-0.0.0.0} exec node /app/build/sse.js
elif [ -f /mcp-proxy-server/build/sse.js ]; then
    echo "启动: node /mcp-proxy-server/build/sse.js"  
    PORT=${PORT:-7860} HOST=${HOST:-0.0.0.0} exec node /mcp-proxy-server/build/sse.js
else
    echo "错误: 找不到 build/sse.js 文件"
    echo "当前目录: $(pwd)"
    echo "查找可能的 Node.js 文件:"
    find / -name "sse.js" -type f 2>/dev/null | head -5
    
    # 如果找不到，保持容器运行以便调试
    echo "保持容器运行以便调试..."
    tail -f /dev/null
fi