build.sh

#!/bin/bash

# RunPanel 企业级嵌入式构建脚本
# 
# 这是用户的主要入口脚本，提供完整的前后端嵌入式构建
# 
# 用法:
#   ./build.sh                    # 使用自动检测的版本
#   ./build.sh v1.2.3            # 使用指定版本
#   ./build.sh --clean           # 清理后构建
#   ./build.sh --dev             # 开发模式构建
#   ./build.sh --verbose         # 详细输出
#
# 作者: RunPanel Team
# 版本: 2.0.0

# 加载公共库
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$SCRIPT_DIR/scripts/lib/common.sh"

# 解析命令行参数
parse_arguments() {
    export CLEAN_BUILD=false
    export DEV_MODE=false
    export VERBOSE=false
    export SPECIFIED_VERSION=""
    
    while [[ $# -gt 0 ]]; do
        case $1 in
            --clean)
                CLEAN_BUILD=true
                shift
                ;;
            --dev)
                DEV_MODE=true
                shift
                ;;
            --verbose|-v)
                VERBOSE=true
                export DEBUG=true
                shift
                ;;
            --help|-h)
                show_help
                exit 0
                ;;
            --version)
                load_version_info
                echo "$VERSION"
                exit 0
                ;;
            -*)
                log_error "未知参数: $1"
                show_help
                exit 1
                ;;
            *)
                if [ -z "$SPECIFIED_VERSION" ]; then
                    SPECIFIED_VERSION="$1"
                else
                    log_error "只能指定一个版本号"
                    exit 1
                fi
                shift
                ;;
        esac
    done
}

# 显示帮助信息
show_help() {
    cat << 'EOF'
RunPanel 企业级嵌入式构建工具

用法:
    ./build.sh [选项] [版本号]

参数:
    版本号              指定构建版本号 (如: v1.2.3)

选项:
    --clean            清理所有构建文件后重新构建
    --dev              开发模式，不进行代码压缩优化
    --verbose, -v      显示详细的构建过程
    --help, -h         显示此帮助信息
    --version          显示当前版本并退出

示例:
    ./build.sh                     # 自动版本构建
    ./build.sh v1.2.3             # 指定版本构建
    ./build.sh --clean            # 清理后构建
    ./build.sh --dev --verbose    # 开发模式详细构建

输出:
    ./dist/runpanel-embedded/     # 嵌入式版本目录
    ├── runpanel                  # 嵌入式二进制文件
    ├── configs/                  # 配置文件
    ├── start.sh                  # 启动脚本
    └── README.md                 # 使用说明

说明:
    嵌入式构建会将前端文件直接嵌入到 Go 二进制文件中，
    实现真正的单文件部署。生成的二进制文件可以独立运行，
    无需外部前端文件依赖。

EOF
}

# 验证项目结构
verify_project_structure() {
    log_step "验证项目结构"
    
    # 检查后端项目
    check_directory "$BACKEND_PROJECT_DIR" "后端项目目录"
    check_file "$BACKEND_PROJECT_DIR/go.mod" "Go模块文件"
    check_directory "$BACKEND_PROJECT_DIR/cmd/paneld" "主程序目录"
    
    # 检查前端项目
    check_directory "$FRONTEND_PROJECT_DIR" "前端项目目录"
    check_file "$FRONTEND_PROJECT_DIR/package.json" "前端包配置文件"
    
    # 检查嵌入目录结构
    ensure_directory "$EMBED_SOURCE_DIR" "嵌入源目录"
    
    log_success "项目结构验证通过"
}

# 清理构建文件
clean_build_files() {
    if [ "$CLEAN_BUILD" == "true" ]; then
        log_step "清理构建文件"
        
        clean_directory "$BUILD_OUTPUT_DIR" "构建输出目录"
        clean_directory "$EMBED_SOURCE_DIR" "嵌入源目录"
        
        # 清理前端构建文件
        if [ -d "$FRONTEND_PROJECT_DIR/dist" ]; then
            clean_directory "$FRONTEND_PROJECT_DIR/dist" "前端构建目录"
        fi
        
        log_success "构建文件清理完成"
    fi
}

# 构建前端
build_frontend() {
    log_step "构建前端应用"
    
    cd "$FRONTEND_PROJECT_DIR"
    
    # 安装依赖
    show_progress 1 3 "安装前端依赖"
    if [ "$VERBOSE" == "true" ]; then
        pnpm install
    else
        pnpm install --silent
    fi
    
    # 构建前端
    show_progress 2 3 "构建前端应用"
    if [ "$DEV_MODE" == "true" ]; then
        log_info "使用开发模式构建（未压缩）"
        VITE_BUILD_MODE=development pnpm run build
    else
        pnpm run build
    fi
    
    # 验证构建结果
    show_progress 3 3 "验证前端构建结果"
    if [ ! -d "dist" ] || [ ! -f "dist/index.html" ]; then
        log_error "前端构建失败，构建文件不存在"
        exit 1
    fi
    
    # 显示构建大小
    local frontend_size=$(get_file_size "dist")
    log_info "前端构建完成，大小: $frontend_size"
    
    log_success "前端构建完成"
}

# 准备嵌入文件
prepare_embed_files() {
    log_step "准备嵌入文件"
    
    # 确保嵌入目录存在
    ensure_directory "$EMBED_SOURCE_DIR"
    
    # 清理旧的嵌入文件
    clean_directory "$EMBED_SOURCE_DIR"
    ensure_directory "$EMBED_SOURCE_DIR"
    
    # 复制前端文件到嵌入目录
    copy_with_log "$FRONTEND_PROJECT_DIR/dist/*" "$EMBED_SOURCE_DIR/" "前端文件"
    
    # 创建版本信息文件
    cat > "$EMBED_SOURCE_DIR/version.json" << EOF
{
  "version": "$VERSION",
  "buildTime": "$BUILD_TIME",
  "gitCommit": "$GIT_COMMIT",
  "gitCommitShort": "$GIT_COMMIT_SHORT",
  "gitTag": "$GIT_TAG",
  "buildType": "embedded",
  "devMode": $DEV_MODE
}
EOF
    
    # 验证嵌入文件
    local embed_file_count=$(find "$EMBED_SOURCE_DIR" -type f | wc -l)
    local embed_size=$(get_file_size "$EMBED_SOURCE_DIR")
    
    log_info "嵌入文件准备完成"
    log_info "  文件数量: $embed_file_count"
    log_info "  总大小: $embed_size"
    
    log_success "嵌入文件准备完成"
}

# 构建后端
build_backend() {
    log_step "构建后端应用"
    
    cd "$BACKEND_PROJECT_DIR"
    
    # 准备构建目录
    local output_dir="$BUILD_OUTPUT_DIR/runpanel-embedded"
    ensure_directory "$output_dir"
    
    # 设置构建标志
    local ldflags="-s -w"
    ldflags="$ldflags -X 'github.com/Run-Panel/RunPanel/internal/version.Version=$VERSION'"
    ldflags="$ldflags -X 'github.com/Run-Panel/RunPanel/internal/version.BuildTime=$BUILD_TIME'"
    ldflags="$ldflags -X 'github.com/Run-Panel/RunPanel/internal/version.GitCommit=$GIT_COMMIT'"
    
    if [ "$DEV_MODE" == "true" ]; then
        log_info "使用开发模式构建（包含调试信息）"
        ldflags="-X 'github.com/Run-Panel/RunPanel/internal/version.Version=$VERSION'"
        ldflags="$ldflags -X 'github.com/Run-Panel/RunPanel/internal/version.BuildTime=$BUILD_TIME'"
        ldflags="$ldflags -X 'github.com/Run-Panel/RunPanel/internal/version.GitCommit=$GIT_COMMIT'"
    fi
    
    # 编译二进制文件
    show_progress 1 2 "编译 Go 应用"
    
    local build_cmd="go build -ldflags \"$ldflags\" -o \"$output_dir/runpanel\" ./cmd/paneld/"
    
    if [ "$VERBOSE" == "true" ]; then
        log_info "构建命令: $build_cmd"
        CGO_ENABLED=0 GOOS=linux GOARCH=amd64 eval $build_cmd -v
    else
        CGO_ENABLED=0 GOOS=linux GOARCH=amd64 eval $build_cmd
    fi
    
    # 验证构建结果
    show_progress 2 2 "验证后端构建结果"
    if [ ! -f "$output_dir/runpanel" ]; then
        log_error "后端构建失败，二进制文件不存在"
        exit 1
    fi
    
    # 设置执行权限
    chmod +x "$output_dir/runpanel"
    
    # 显示构建大小
    local binary_size=$(get_file_size "$output_dir/runpanel")
    log_info "后端构建完成，大小: $binary_size"
    
    log_success "后端构建完成"
}

# 创建发布包
create_release_package() {
    log_step "创建发布包"
    
    local output_dir="$BUILD_OUTPUT_DIR/runpanel-embedded"
    
    # 复制配置文件
    show_progress 1 4 "复制配置文件"
    copy_with_log "$BACKEND_PROJECT_DIR/configs" "$output_dir/" "配置文件"
    
    # 创建启动脚本
    show_progress 2 4 "创建启动脚本"
    cat > "$output_dir/start.sh" << 'EOF'
#!/bin/bash

# RunPanel 嵌入式版本启动脚本
# 此版本包含嵌入的前端文件，无需外部依赖

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BINARY_PATH="$SCRIPT_DIR/runpanel"
CONFIG_PATH="$SCRIPT_DIR/configs/config.yaml"

echo "🚀 启动 RunPanel (嵌入式版本)"
echo "================================="
echo "二进制文件: $BINARY_PATH"
echo "配置文件: $CONFIG_PATH"
echo "启动时间: $(date)"
echo ""

# 检查文件是否存在
if [ ! -f "$BINARY_PATH" ]; then
    echo "❌ 错误: 二进制文件不存在: $BINARY_PATH"
    exit 1
fi

if [ ! -f "$CONFIG_PATH" ]; then
    echo "❌ 错误: 配置文件不存在: $CONFIG_PATH"
    exit 1
fi

# 启动应用
echo "✅ 启动应用..."
exec "$BINARY_PATH" -config "$CONFIG_PATH" "$@"
EOF
    
    chmod +x "$output_dir/start.sh"
    
    # 创建使用说明
    show_progress 3 4 "创建使用说明"
    cat > "$output_dir/README.md" << EOF
# RunPanel 嵌入式版本

版本: $VERSION  
构建时间: $BUILD_TIME  
构建类型: 嵌入式 (前端文件已嵌入)

## 📁 文件说明

- \`runpanel\` - 主程序二进制文件（已嵌入前端）
- \`start.sh\` - 启动脚本
- \`configs/\` - 配置文件目录

## 🚀 启动方式

### 方式1: 使用启动脚本（推荐）
\`\`\`bash
./start.sh
\`\`\`

### 方式2: 直接运行二进制文件
\`\`\`bash
./runpanel -config configs/config.yaml
\`\`\`

## 🌐 访问地址

- 前端界面: http://localhost:8081
- API 文档: http://localhost:8081/docs
- Swagger: http://localhost:8081/swagger/index.html

## ✨ 特性

- ✅ 单文件部署：前端文件已嵌入二进制文件
- ✅ 零依赖：无需外部 Web 服务器
- ✅ 跨平台：支持 Linux/Windows/macOS
- ✅ 企业级：适合生产环境部署

## 🔧 配置

主要配置文件：\`configs/config.yaml\`

## 📞 支持

如有问题，请联系 RunPanel 团队或查看项目文档。
EOF
    
    # 生成构建信息
    show_progress 4 4 "生成构建信息"
    cat > "$output_dir/build-info.json" << EOF
{
  "version": "$VERSION",
  "buildTime": "$BUILD_TIME",
  "gitCommit": "$GIT_COMMIT",
  "gitCommitShort": "$GIT_COMMIT_SHORT",
  "gitTag": "$GIT_TAG",
  "buildType": "embedded",
  "devMode": $DEV_MODE,
  "binarySize": "$(get_file_size "$output_dir/runpanel")",
  "embedSize": "$(get_file_size "$EMBED_SOURCE_DIR")",
  "totalFiles": $(find "$output_dir" -type f | wc -l)
}
EOF
    
    log_success "发布包创建完成"
}

# 验证最终构建
verify_final_build() {
    log_step "验证最终构建"
    
    local output_dir="$BUILD_OUTPUT_DIR/runpanel-embedded"
    
    # 检查必要文件
    local required_files=(
        "$output_dir/runpanel"
        "$output_dir/start.sh"
        "$output_dir/configs/config.yaml"
        "$output_dir/README.md"
        "$output_dir/build-info.json"
    )
    
    for file in "${required_files[@]}"; do
        check_file "$file" "必要文件"
    done
    
    # 测试二进制文件
    if "$output_dir/runpanel" --version &> /dev/null; then
        log_info "二进制文件版本检查通过"
    else
        log_warning "二进制文件版本检查失败（可能是正常的）"
    fi
    
    # 显示构建统计
    local total_size=$(get_file_size "$output_dir")
    local binary_size=$(get_file_size "$output_dir/runpanel")
    local file_count=$(find "$output_dir" -type f | wc -l)
    
    log_info "构建统计信息:"
    log_info "  总大小: $total_size"
    log_info "  二进制大小: $binary_size"
    log_info "  文件数量: $file_count"
    
    log_success "最终构建验证通过"
}

# 显示构建摘要
show_build_summary() {
    local output_dir="$BUILD_OUTPUT_DIR/runpanel-embedded"
    
    log_separator
    log_success "🎉 RunPanel 嵌入式构建完成！"
    log_separator
    
    echo ""
    echo "📊 构建摘要:"
    echo "  版本号:     $VERSION"
    echo "  构建时间:   $BUILD_TIME"
    echo "  构建模式:   $([ "$DEV_MODE" == "true" ] && echo "开发模式" || echo "生产模式")"
    echo "  Git 提交:   $GIT_COMMIT_SHORT"
    if [ -n "$GIT_TAG" ]; then
        echo "  Git 标签:   $GIT_TAG"
    fi
    echo ""
    
    echo "📁 输出目录:"
    echo "  $output_dir"
    echo ""
    
    echo "📦 主要文件:"
    echo "  二进制文件: runpanel ($(get_file_size "$output_dir/runpanel"))"
    echo "  启动脚本:   start.sh"
    echo "  配置文件:   configs/"
    echo "  使用说明:   README.md"
    echo ""
    
    echo "🚀 启动方式:"
    echo "  cd $output_dir"
    echo "  ./start.sh"
    echo ""
    
    echo "🌐 访问地址:"
    echo "  前端界面: http://localhost:8081"
    echo "  API 文档: http://localhost:8081/docs"
    echo ""
    
    echo "💡 提示:"
    echo "  嵌入式版本包含前端文件，可独立部署"
    echo "  只需复制整个目录到目标服务器即可运行"
    
    log_separator
}

# 主构建流程
main() {
    # 解析参数
    parse_arguments "$@"
    
    # 加载版本信息
    load_version_info
    
    # 如果指定了版本，覆盖自动检测的版本
    if [ -n "$SPECIFIED_VERSION" ]; then
        VERSION="$SPECIFIED_VERSION"
        log_info "使用指定版本: $VERSION"
    fi
    
    # 显示构建信息
    show_build_info
    
    # 验证构建工具
    verify_build_tools
    
    # 验证项目结构
    verify_project_structure
    
    # 清理构建文件
    clean_build_files
    
    # 构建流程
    build_frontend
    prepare_embed_files
    build_backend
    create_release_package
    verify_final_build
    
    # 显示构建摘要
    show_build_summary
}

# 运行主流程
main "$@"