下面是一段格式化脚本



```vba
'Private Sub Worksheet_SelectionChange(ByVal Target As Range)
'    ' 错误处理，避免意外错误导致程序中断
'    On Error GoTo ErrorHandler
'
'    ' 只处理单个单元格的选择
'    If Target.CountLarge > 1 Then Exit Sub
'
'    ' 只处理包含数字值的单元格
'    If IsNumeric(Target.Value) And Not IsEmpty(Target) Then
'        ' 禁用屏幕更新和事件触发，提高性能并防止递归
'        Application.EnableEvents = False
'        Application.ScreenUpdating = False
'
'        ' 获取原始值并转换为字符串
'        Dim originalValue As String
'        originalValue = CStr(Target.Value)
'
'        ' 查找小数点的位置
'        Dim decimalPosition As Integer
'        decimalPosition = InStr(originalValue, ".")
'
'        If decimalPosition > 0 Then
'            ' 如果存在小数点且小数点后位数超过2位
'            If Len(originalValue) - decimalPosition > 2 Then
'                ' 直接截取到小数点后两位（不做四舍五入）
'                Target.Value = Left(originalValue, decimalPosition + 2)
'            End If
'        End If
'
'        ' 无论是否截断，都格式化为两位小数显示
'        Target.NumberFormat = "0.00"
'
'    End If
'
'ExitHandler:
'    ' 恢复设置
'    Application.EnableEvents = True
'    Application.ScreenUpdating = True
'    Exit Sub
'
'ErrorHandler:
'    ' 发生错误时也恢复设置
'    Resume ExitHandler
'End Sub




Sub FormatChemicalComposition()
    Dim selectedRange As Range
    Dim dataRange As Range
    Dim lastRow As Long
    Dim i As Long, j As Long
    Dim colIndex As Integer
    Dim cellValue As Variant
    Dim decimalPlaces As Integer
    Dim tempArray As Variant
    
    ' 获取当前选中的行范围
    Set selectedRange = Selection
    If selectedRange Is Nothing Then Exit Sub
    
    ' 获取工作表的最后一行
    lastRow = Cells(Rows.Count, "D").End(xlUp).Row
    
    ' 确定要处理的D-M列范围（只处理选中行对应的D-M列）
    Set dataRange = Range("D" & selectedRange.Row & ":M" & selectedRange.Row + selectedRange.Rows.Count - 1)
    
    ' 将数据读取到数组中进行批量处理（提高效率）
    tempArray = dataRange.Value
    
    ' 禁用屏幕更新和自动计算
    Application.ScreenUpdating = False
    Application.Calculation = xlCalculationManual
    Application.EnableEvents = False
    
    ' 设置整个区域为文本格式（防止0.20显示为0.2）
    dataRange.NumberFormat = "@"
    
    ' 批量处理数组中的数据
    For i = 1 To UBound(tempArray, 1)
        For j = 1 To UBound(tempArray, 2)
            colIndex = j + 3 ' D列是第4列，所以j=1对应D列，j=2对应E列，以此类推
            
            ' 跳过空单元格
            If Not IsEmpty(tempArray(i, j)) And IsNumeric(tempArray(i, j)) Then
                ' 根据列确定小数位数
                Select Case colIndex
                    Case 7, 8, 12 ' G列(7)、H列(8)、L列(12) 需要三位小数
                        decimalPlaces = 3
                    Case Else ' 其他列(D-F, I-K, M) 需要两位小数
                        decimalPlaces = 2
                End Select
                
                ' 格式化数字（截断而不四舍五入）
                tempArray(i, j) = FormatNumberWithPrecision(CDbl(tempArray(i, j)), decimalPlaces)
            End If
        Next j
    Next i
    
    ' 将处理后的数据一次性写回工作表
    dataRange.Value = tempArray
    
    ' 恢复设置
    Application.ScreenUpdating = True
    Application.Calculation = xlCalculationAutomatic
    Application.EnableEvents = True
    
    MsgBox "格式化完成！共处理了 " & dataRange.Rows.Count & " 行数据。", vbInformation
End Sub

' 辅助函数：格式化数字到指定小数位（截断而不四舍五入）
Function FormatNumberWithPrecision(numberValue As Double, decimalPlaces As Integer) As String
    Dim strValue As String
    Dim decimalPos As Integer
    Dim integerPart As String
    Dim decimalPart As String
    
    ' 将数字转换为字符串
    strValue = CStr(numberValue)
    
    ' 查找小数点位置
    decimalPos = InStr(strValue, ".")
    
    If decimalPos > 0 Then
        ' 分离整数和小数部分
        integerPart = Left(strValue, decimalPos - 1)
        decimalPart = Mid(strValue, decimalPos + 1)
        
        ' 截断小数部分到指定位数
        If Len(decimalPart) > decimalPlaces Then
            decimalPart = Left(decimalPart, decimalPlaces)
        Else
            ' 如果小数位数不足，补零
            decimalPart = decimalPart & String(decimalPlaces - Len(decimalPart), "0")
        End If
        
        ' 重新组合
        FormatNumberWithPrecision = integerPart & "." & decimalPart
    Else
        ' 没有小数部分，添加小数点和零
        FormatNumberWithPrecision = strValue & "." & String(decimalPlaces, "0")
    End If
End Function

'' 可以绑定到快捷键或按钮的简化版本
'Sub QuickFormatSelection()
'    ' 确保选择的是行
'    If Selection.Columns.Count > 1 Then
'        MsgBox "请选择整行或若干行！", vbExclamation
'        Exit Sub
'    End If
'
'    ' 调用主格式化函数
'    FormatChemicalComposition
'End Sub
Private Sub Worksheet_SelectionChange(ByVal Target As Range)

End Sub



```

一个格式化化学成分的脚本

下面的脚本，可以实现镜像分支与二开分支的同步。



```bash
# .cnb/.scripts/safe-sync-upstream.sh
#!/bin/bash
set -eo pipefail

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}🚀 开始安全同步上游仓库...${NC}"
echo "---------------------------------"

# 1. 基础配置
git config --global user.name "CI Sync Bot"
git config --global user.email "ci@example.com"

# 2. 添加上游仓库
if ! git remote | grep -q "upstream"; then
  git remote add upstream https://github.com/Kele-Bingtang/vitepress-theme-teek
  echo -e "${GREEN}✅ 已添加上游仓库${NC}"
fi

# 3. 分支定义（严格隔离）
readonly UPSTREAM_BRANCHES=("main" "dev")
readonly LOCAL_MIRROR_PREFIX="mirror_"
readonly CUSTOM_BRANCHES=("master" "develop")
readonly SYNC_DEFAULT_BRANCH=true  # 是否同步默认分支
readonly DEFAULT_BRANCH="main"     # 默认分支名称
readonly SYNC_SOURCE="master"      # 同步源分支

# 4. 获取最新代码
echo -e "${GREEN}🔍 正在获取上游最新代码...${NC}"
git fetch upstream --prune --quiet
echo -e "${GREEN}✅ 已获取上游最新代码${NC}"
echo "---------------------------------"
echo -e "${GREEN}🔍 正在获取本地最新代码...${NC}"
git fetch origin --prune --quiet
echo -e "${GREEN}✅ 已获取本地最新代码${NC}"
echo "---------------------------------"

# 5. 保存当前分支
original_branch=$(git branch --show-current)
trap '[[ -n "$original_branch" ]] && git checkout "$original_branch" 2>/dev/null || true' EXIT

# 6. 创建本地镜像分支
create_mirror_branches() {
  for branch in "${UPSTREAM_BRANCHES[@]}"; do
    local mirror_branch="${LOCAL_MIRROR_PREFIX}${branch}"
    local upstream_ref="upstream/${branch}"
    
    echo -e "${YELLOW}🔄 正在同步镜像分支: ${mirror_branch}${NC}"
    
    if git rev-parse --verify -q "$mirror_branch" >/dev/null; then
      # 分支已存在，检查是否需要更新
      if ! git diff --quiet "$mirror_branch" "$upstream_ref"; then
        git checkout -B "$mirror_branch" "$upstream_ref" --quiet
        git push origin "$mirror_branch" --force 2>/dev/null
        echo -e "${GREEN}   ✅ 已更新: ${mirror_branch} -> $(git rev-parse --short HEAD)${NC}"
      else
        echo -e "   🔹 无需更新: ${mirror_branch} 已是最新"
      fi
    else
      # 分支不存在，创建新分支
      git checkout -B "$mirror_branch" "$upstream_ref" --quiet
      git push origin "$mirror_branch" 2>/dev/null
      echo -e "${GREEN}   ✅ 已创建: ${mirror_branch} -> $(git rev-parse --short HEAD)${NC}"
    fi
  done
}

# 7. 安全合并测试（改进版）
safe_merge_test() {
  echo "DEBUG: 进入safe_merge_test: $1, $2"
  local custom_branch=$1
  local mirror_branch="${LOCAL_MIRROR_PREFIX}${2}"

  # 添加标题输出（确保在函数开始时输出）
  echo -e "${YELLOW}🛡️ 检查分支: ${custom_branch}${NC}"

  # 保存当前分支
  local current_branch=$(git symbolic-ref --short HEAD 2>/dev/null)
  local stash_created=0
  local result=0
  
  # 如果有未提交的更改，先stash
  if ! git diff --quiet || ! git diff --cached --quiet; then
    git stash push --quiet --include-untracked >/dev/null 2>&1
    stash_created=1
  fi

  # 检查本地分支是否存在
  if git rev-parse --verify -q "$custom_branch" >/dev/null; then
    echo -e "${GREEN}   ✅ 使用本地分支: ${custom_branch}${NC}"
    local temp_branch="temp_merge_${custom_branch}_$(date +%s)"
    
    if ! git checkout -b "$temp_branch" "$custom_branch" --quiet >/dev/null 2>&1; then
      echo -e "${RED}   ❌ 创建测试分支失败${NC}"
      result=1
    elif git merge --no-commit --no-ff "$mirror_branch" --quiet >/dev/null 2>&1; then
      echo -e "${GREEN}   ✅ 可自动合并: ${custom_branch} ← ${mirror_branch}${NC}"
      result=0
    else
      echo -e "${RED}⛔ 存在合并冲突: ${custom_branch} ← ${mirror_branch}${NC}"
      result=1
    fi
    
    # 清理临时分支
    git merge --abort --quiet >/dev/null 2>&1 || true
    git checkout "$current_branch" --quiet >/dev/null 2>&1 || true
    git branch -D "$temp_branch" --quiet >/dev/null 2>&1 || true
  
  # 检查origin分支是否存在
  elif git rev-parse --verify -q "origin/$custom_branch" >/dev/null; then
    echo -e "${YELLOW}   🔄 从origin检出分支进行测试: ${custom_branch}${NC}"
    local temp_branch="temp_test_${custom_branch}_$(date +%s)"
    
    if ! git checkout -b "$temp_branch" "origin/$custom_branch" --quiet >/dev/null 2>&1; then
      echo -e "${RED}   ❌ 检出分支失败: ${custom_branch}${NC}"
      result=1
    elif git merge --no-commit --no-ff "$mirror_branch" --quiet >/dev/null 2>&1; then
      echo -e "${GREEN}   ✅ 可自动合并: ${custom_branch} ← ${mirror_branch}${NC}"
      result=0
    else
      echo -e "${RED}⛔ 存在合并冲突: ${custom_branch} ← ${mirror_branch}${NC}"
      result=1
    fi
    
    # 清理临时分支
    git merge --abort --quiet >/dev/null 2>&1 || true
    git checkout "$current_branch" --quiet >/dev/null 2>&1 || true
    git branch -D "$temp_branch" --quiet >/dev/null 2>&1 || true
  
  # 都不存在
  else
    echo -e "${YELLOW}   ⚠️ 分支 ${custom_branch} 在本地和origin均不存在，跳过合并测试${NC}"
    result=2
  fi

  # 确保恢复原分支
  [[ -n "$current_branch" ]] && git checkout "$current_branch" --quiet >/dev/null 2>&1 || true
  
  return $result
}

# 8. 执行合并操作（改进版）
perform_merge() {
  local custom_branch=$1
  local mirror_branch="${LOCAL_MIRROR_PREFIX}${2}"

  # 检查本地分支是否存在
  if git rev-parse --verify -q "$custom_branch" >/dev/null; then
    if ! git diff --quiet "$custom_branch" "$mirror_branch"; then
      if git merge --no-edit --no-ff "$mirror_branch" >/dev/null 2>&1; then
        echo -e "${GREEN}   ✅ 已合并更新: ${custom_branch} ← ${mirror_branch}${NC}"
        return 0
      else
        echo -e "${RED}💥 合并冲突: ${custom_branch} ← ${mirror_branch}${NC}"
        return 1
      fi
    else
      echo "   🔹 无需合并: ${custom_branch} 已包含所有更新"
      return 0
    fi
  
  # 检查origin分支是否存在
  elif git rev-parse --verify -q "origin/$custom_branch" >/dev/null; then
    echo -e "${YELLOW}   🔄 从origin检出分支进行合并: ${custom_branch}${NC}"
    
    # 创建并切换到分支
    if git checkout -b "$custom_branch" "origin/$custom_branch" --quiet >/dev/null 2>&1; then
      if git merge --no-edit --no-ff "$mirror_branch" >/dev/null 2>&1; then
        echo -e "${GREEN}   ✅ 已合并更新: ${custom_branch} ← ${mirror_branch}${NC}"
        # 设置上游跟踪
        git branch -u "origin/$custom_branch" >/dev/null 2>&1
        return 0
      else
        echo -e "${RED}💥 合并冲突: ${custom_branch} ← ${mirror_branch}${NC}"
        return 1
      fi
    else
      echo -e "${RED}   ❌ 无法检出分支: ${custom_branch}${NC}"
      return 1
    fi
  
  # 都不存在
  else
    echo -e "${YELLOW}   ⚠️ 分支 ${custom_branch} 在本地和origin均不存在，跳过合并${NC}"
    return 2
  fi
}

# 9. 获取分支状态信息（改进版）
get_branch_status() {
  local custom_branch=$1
  local mirror_branch=$2
  
  # 检查本地分支
  if git rev-parse --verify -q "$custom_branch" >/dev/null; then
    if git diff --quiet "$custom_branch" "$mirror_branch"; then
      echo "   ${custom_branch} 与 ${mirror_branch} 同步"
    else
      local behind_count=$(git rev-list --count "${custom_branch}..${mirror_branch}" 2>/dev/null || echo "未知")
      if [[ "$behind_count" -eq "0" ]]; then
          echo "   ${custom_branch} 与 ${mirror_branch} 同步"
      else
          echo "   ${custom_branch} 落后于 ${mirror_branch} (差异: ${behind_count} commits)"
      fi
    fi
  
  # 检查origin分支
  elif git rev-parse --verify -q "origin/$custom_branch" >/dev/null; then
    # 创建临时分支进行比较
    local temp_branch="temp_status_${custom_branch}_$(date +%s)"
    if git checkout -b "$temp_branch" "origin/$custom_branch" --quiet >/dev/null 2>&1; then
      if git diff --quiet "$temp_branch" "$mirror_branch"; then
        echo "   ${custom_branch} (origin) 与 ${mirror_branch} 同步"
      else
        local behind_count=$(git rev-list --count "${temp_branch}..${mirror_branch}" 2>/dev/null || echo "未知")
        echo "   ${custom_branch} (origin) 落后于 ${mirror_branch} (差异: ${behind_count} commits)"
      fi
      # 清理临时分支并恢复
      git checkout - --quiet >/dev/null 2>&1
      git branch -D "$temp_branch" --quiet >/dev/null 2>&1
    else
      echo "   ${custom_branch} -> 状态检查失败"
    fi
  
  # 都不存在
  else
    echo "   ${custom_branch} -> 分支不存在"
  fi
}

# 10. 同步默认分支（改进版）
sync_default_branch() {
    local default_branch="main"
    local custom_branch="master"
    
    echo "---------------------------------"
    echo -e "${YELLOW}🔄 同步默认分支: ${default_branch} -> ${custom_branch}${NC}"
    
    # 检查 custom_branch 是否存在
    if ! git rev-parse --verify -q "$custom_branch" >/dev/null; then
        echo "   ⚠️  二开分支 ${custom_branch} 不存在，跳过同步"
        return 1
    fi
    
    # 处理 default_branch
    if git rev-parse --verify -q "$default_branch" >/dev/null; then
        # default_branch 已存在，进行同步
        if ! git diff --quiet "$default_branch" "$custom_branch"; then
            git checkout "$default_branch" --quiet >/dev/null 2>&1
            if git merge --no-edit --no-ff "$custom_branch" --quiet >/dev/null 2>&1; then
                echo -e "${GREEN}   ✅ 已同步: ${default_branch} ← ${custom_branch}${NC}"
            else
                echo -e "${RED}   ❌ 同步失败: ${default_branch} ← ${custom_branch}${NC}"
                git merge --abort --quiet >/dev/null 2>&1
            fi
        else
            echo "   🔹 无需同步: ${default_branch} 已与 ${custom_branch} 同步"
        fi
    else
        # default_branch 不存在，创建并同步
        git checkout -b "$default_branch" "$custom_branch" --quiet >/dev/null 2>&1
        echo -e "${GREEN}   ✅ 已创建: ${default_branch} → ${custom_branch}${NC}"
        
        # 如果远程存在 default_branch，设置跟踪
        if git rev-parse --verify -q "origin/$default_branch" >/dev/null; then
            git branch -u "origin/$default_branch" >/dev/null 2>&1
            echo -e "${GREEN}   📡 已设置远程跟踪: ${default_branch} -> origin/${default_branch}${NC}"
        fi
    fi
    
    # 恢复原分支
    git checkout "$original_branch" --quiet >/dev/null 2>&1
    return 0
}

# 在主流程中调用（在最终状态报告前）
sync_default_branch

# ----------------------------
# 主执行流程
# ----------------------------

# A. 创建/更新镜像分支
create_mirror_branches

# B. 安全合并检测
echo -e "${YELLOW}🔎 正在检查合并兼容性...${NC}"
conflict_detected=0
skip_count=0


# 在主循环前添加调试
echo "DEBUG: 开始检查合并兼容性，分支数量: ${#CUSTOM_BRANCHES[@]}"
for i in "${!CUSTOM_BRANCHES[@]}"; do
  echo "DEBUG: 准备检查分支 ${CUSTOM_BRANCHES[$i]} -> ${UPSTREAM_BRANCHES[$i]}"
done

for i in "${!UPSTREAM_BRANCHES[@]}"; do
  echo "---------------------------------"
  result=$(safe_merge_test "${CUSTOM_BRANCHES[$i]}" "${UPSTREAM_BRANCHES[$i]}")
  echo "$result"
  
  # 解析返回结果
  if [[ "$result" == *"存在合并冲突"* ]]; then
    conflict_detected=1
  elif [[ "$result" == *"均不存在"* ]]; then
    skip_count=$((skip_count + 1))
  fi
done

# C. 执行合并（仅当无冲突且不是全部跳过）
if [[ $conflict_detected -eq 0 && $skip_count -lt ${#CUSTOM_BRANCHES[@]} ]]; then
  echo "---------------------------------"
  echo -e "${GREEN}🚀 正在执行安全合并...${NC}"
  for i in "${!UPSTREAM_BRANCHES[@]}"; do
    perform_merge "${CUSTOM_BRANCHES[$i]}" "${UPSTREAM_BRANCHES[$i]}"
  done
else
  echo "---------------------------------"
  if [[ $conflict_detected -eq 1 ]]; then
    echo -e "${RED}⚠️ 检测到冲突，已中止自动合并${NC}"
  elif [[ $skip_count -eq ${#CUSTOM_BRANCHES[@]} ]]; then
    echo -e "${YELLOW}⚠️ 所有二开分支均不存在，跳过合并${NC}"
  fi
fi

# D. 同步默认分支
if [[ "$SYNC_DEFAULT_BRANCH" == "true" ]]; then
    sync_default_branch "$DEFAULT_BRANCH" "$SYNC_SOURCE"
fi

# E. 最终状态报告
echo "================================="
echo -e "${GREEN}🌿 分支状态摘要:${NC}"
echo "---------------------------------"
echo -e "${YELLOW}【上游镜像分支】${NC}"
for branch in "${UPSTREAM_BRANCHES[@]}"; do
  mirror_branch="${LOCAL_MIRROR_PREFIX}${branch}"
  echo "   ${mirror_branch} -> $(git rev-parse --short ${mirror_branch} 2>/dev/null || echo '未知')"
done

echo "---------------------------------"
echo -e "${YELLOW}【二开分支】${NC}"
for branch in "${CUSTOM_BRANCHES[@]}"; do
  if git rev-parse --verify -q "$branch" >/dev/null; then
    echo "   ${branch} -> $(git rev-parse --short ${branch})"
  elif git rev-parse --verify -q "origin/$branch" >/dev/null; then
    echo "   ${branch} -> (仅存在于origin)"
  else
    echo "   ${branch} -> 不存在"
  fi
done

echo "---------------------------------"
echo -e "${YELLOW}【分支差异状态】${NC}"
for i in "${!UPSTREAM_BRANCHES[@]}"; do
  mirror_branch="${LOCAL_MIRROR_PREFIX}${UPSTREAM_BRANCHES[$i]}"
  custom_branch="${CUSTOM_BRANCHES[$i]}"
  get_branch_status "$custom_branch" "$mirror_branch"
done

echo "---------------------------------"
echo -e "${YELLOW}【远程分支状态】${NC}"
git remote show origin 2>/dev/null | grep -E '^(Local|Remote) branch' -A1 | sed 's/^/   /' || echo "   远程状态检查跳过"
echo "---------------------------------"
echo "🕒 最后同步时间: $(date '+%Y-%m-%d %H:%M:%S')"
echo "================================="
echo -e "${GREEN}✅ 同步完成。当前分支: ${original_branch}${NC}"
echo "================================="
echo "当前仓库分支关系图: "
echo "---------------------------------"
git branch -avv 2>/dev/null | grep -E '^(  |* )' | sed 's/^/   /' || echo "   无法获取分支关系图"
echo "================================="
echo "🔧 请根据需要手动合并或更新分支。"
echo "================================="

# 在脚本最后添加推送环节
echo "---------------------------------"
echo -e "${YELLOW}🚀 推送二开分支到origin...${NC}"

# 推送master分支
if git push origin master --quiet 2>/dev/null; then
    echo -e "${GREEN}   ✅ 已推送: master → origin/master${NC}"
else
    echo -e "${RED}   ❌ 推送失败: master → origin/master${NC}"
fi

# 推送develop分支  
if git push origin develop --quiet 2>/dev/null; then
    echo -e "${GREEN}   ✅ 已推送: develop → origin/develop${NC}"
else
    echo -e "${RED}   ❌ 推送失败: develop → origin/develop${NC}"
fi

echo "---------------------------------"

```

一个git同步脚本.md

钉钉通知机器人创建

根据您的流水线配置，我将分析需要预设的环境变量以及建议的改进方案：

### 现有环境变量分析

1. **基础变量**（已在 &envs 中定义）：
   - `PROJECT_NAME`
   - `BUILD_OUTPUT_DIR`
   - `EDGEONE_PAGES_API_TOKEN` (通过 secrets 导入)
   - `DEPLOY_TO_EDGEONE`
   - `SEND_NOTIFICATION`
   - `DEPLOY_TRIGGER`

2. **新增功能需要的变量**：
   - **云服务器同步(rsync)**：
     - `SYNC_TO_ECS` (控制开关)
     - `SSH_USER`
     - `SSH_KEY`
     - `SSH_PORT`
     - `ECS_IP`
   
   - **Gitee同步**：
     - `SYNC_TO_GITEE` (主仓库开关)
     - `GITEE_USERNAME`
     - `GITEE_ACCESS_TOKEN`
     - `SYNC_TO_GITEE_MIRROR` (镜像仓库开关)
     - `GITEE_MIRROR_USERNAME`
     - `GITEE_MIRROR_TOKEN`
   
   - **CDN刷新**：
     - `TENCENT_OPSRE_AK` (腾讯云AK)
     - `TENCENT_OPSRE_SK` (腾讯云SK)
     - `DOMAIN` (可复用已有的 onedayxyy.cn)
   
   - **企业微信通知**：
     - `WEBHOOK_URL` (已在 imports 中)
     - `OCI_REVIEW_ROBOT` (已在 imports 中)

### 改进建议

1. **更新 &envs 部分**：
```yaml
.env: &envs
  # 基础变量
  PROJECT_NAME: vitepress-theme-teek-ysundy-blog
  BUILD_OUTPUT_DIR: .vitepress/.dist
  EDGEONE_PAGES_API_TOKEN: { { secrets.EDGEONE_PAGES_API_TOKEN } }
  
  # 部署控制
  DEPLOY_TO_EDGEONE: "true"
  SEND_NOTIFICATION: "false"
  DEPLOY_TRIGGER: "deploy"
  
  # 新增功能开关
  SYNC_TO_ECS: "false"
  SYNC_TO_GITEE: "false"
  SYNC_TO_GITEE_MIRROR: "false"
  
  # 通用域名配置
  DOMAIN: "onedayxyy.cn"
```

2. **敏感数据处理建议**：
- 所有密钥类变量(SSH_KEY, GITEE_ACCESS_TOKEN等)应通过`imports`引入
- 建议创建单独的secret管理文件，例如`secrets.yml`：

```yaml
# secrets.yml
envs:
  # 云服务器相关
  SSH_USER: { { secrets.SSH_USER } }
  SSH_KEY: { { secrets.SSH_KEY } }
  SSH_PORT: { { secrets.SSH_PORT } }
  ECS_IP: { { secrets.ECS_IP } }
  
  # Gitee相关
  GITEE_USERNAME: { { secrets.GITEE_USERNAME } }
  GITEE_ACCESS_TOKEN: { { secrets.GITEE_ACCESS_TOKEN } }
  GITEE_MIRROR_USERNAME: { { secrets.GITEE_MIRROR_USERNAME } }
  GITEE_MIRROR_TOKEN: { { secrets.GITEE_MIRROR_TOKEN } }
  
  # 腾讯云CDN
  TENCENT_OPSRE_AK: { { secrets.TENCENT_OPSRE_AK } }
  TENCENT_OPSRE_SK: { { secrets.TENCENT_OPSRE_SK } }
```

3. **分支特定变量建议**：
- 在分支配置中覆盖默认值，如dev分支：
```yaml
dev:
  push:
    builder:
      ...
      env:
        <<: *envs
        PROJECT_NAME: vitepress-theme-teek-dev
        SYNC_TO_GITEE: "true"  # dev分支开启Gitee同步
```

4. **条件判断优化**：
- 可以增加更精细的控制变量，如：
```yaml
# 在envs中添加
SYNC_STRATEGY: "all"  # 可选 all/ecs-only/gitee-only/none
```

### 最佳实践建议

1. **变量分类管理**：
   - 基础配置变量：直接写在流水线中
   - 敏感数据：通过secrets导入
   - 环境特定变量：在分支/标签配置中覆盖

2. **文档说明**：
   在流水线顶部添加注释说明各变量用途：
   ```yaml
   # 变量说明：
   # DEPLOY_TO_EDGEONE - 控制EdgeOne部署(true/false)
   # SYNC_TO_ECS - 控制云服务器同步(true/false)
   # ...其他变量说明
   ```

3. **默认安全**：
   所有敏感操作(SYNC_TO_ECS等)默认设为false，仅在需要时开启

这样改进后，您的流水线将具有更好的可维护性和安全性，同时支持所有新增功能的需求。

新文件

以下是测试已上传到制品库的 `docker.cnb.cool/ysundy/images/debian:all` 镜像的完整步骤：

### 1. 首先拉取镜像
```bash
docker pull docker.cnb.cool/ysundy/images/debian:all
```

### 2. 基础功能测试
```bash
# 测试容器基础运行
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "echo '容器启动成功'"

# 验证核心工具版本
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  echo 'Node版本: $(node -v)' && 
  echo 'Go版本: $(go version)' && 
  echo 'Yarn版本: $(yarn --version)' && 
  echo 'PNPM版本: $(pnpm -v)'
"
```

### 3. 验证动态环境变量
```bash
# 验证构建时版本覆盖（如果需要重新构建）
docker build --build-arg NODE_VERSION=20.15.0 --build-arg GO_VERSION=1.22.0 -t test-image .

# 测试容器基础运行
docker run -it --rm test-image zsh -c "echo '容器启动成功'"

# 验证核心工具版本
docker run -it --rm test-image zsh -c "
  echo 'Node版本: $(node -v)' && 
  echo 'Go版本: $(go version)' && 
  echo 'Yarn版本: $(yarn --version)' && 
  echo 'PNPM版本: $(pnpm -v)'
"



# 验证运行时环境变量
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  echo 'NODE_VERSION: $NODE_VERSION' && 
  echo 'GO_VERSION: $GO_VERSION'
"
```

### 4. 验证懒加载性能
```bash
# 测试shell启动速度
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  echo '首次加载时间:' && 
  time (source ~/.zshrc) && 
  echo '\n二次加载时间:' && 
  time (source ~/.zshrc)
"
```

### 5. 验证开发环境功能
```bash
# 测试code-server插件
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  ls -l ~/.local/share/code-server/extensions | wc -l
"

# 测试别名功能
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  alias | grep 'docker compose' && 
  alias | grep 'cdw'
"
```

### 6. 验证持久化配置
```bash
# 测试Yarn PnP配置
docker run -it --rm docker.cnb.cool/ysundy/images/debian:all zsh -c "
  cat /workspace/.yarnrc.yml | grep 'nodeLinker: pnp' && 
  yarn config get nodeLinker
"
```

### 7. 完整集成测试（推荐）
```bash
# 启动交互式容器进行全面测试
docker run -it --rm \
  -v $(pwd):/workspace \
  -p 8080:8080 \
  docker.cnb.cool/ysundy/images/debian:all

# 在容器内手动验证：
# 1. code-server 是否正常启动
# 2. 所有别名是否生效
# 3. 开发工具链是否完整
```

### 测试要点说明：
1. `--rm` 参数保证测试后自动清理容器
2. 对于需要持久化的测试（如Yarn PnP），可以添加 `-v $(pwd):/workspace` 挂载卷
3. 核心验证应包括：
   - 基础工具链（node/go/yarn）
   - 开发环境（code-server插件）
   - Shell配置（zsh/别名/历史记录）
   - 性能表现（懒加载速度）

如果需要测试特定功能，可以调整命令中的验证语句。所有测试命令都可以直接复制执行。

