#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF'
用法:
  bash scripts/dev/setup-worktree.sh <worktree-path> <branch-name> [base-branch] [env-mode]

参数:
  worktree-path  新 worktree 的目录路径
  branch-name    分支名称，例如 feature/xxx（新建或已有均可）
  base-branch    基线分支，默认 develop（仅新建分支时使用）
  env-mode       环境变量处理方式: copy | link，默认 copy
                 copy: 复制 .env 并自动分配独立端口和数据库
                 link: 软链共享 .env（端口与主环境相同，不能同时运行）

示例:
  # 创建新分支的 worktree
  bash scripts/dev/setup-worktree.sh ../ffworkspace-wt/my-feature feature/my-feature

  # 检出已有远端分支
  bash scripts/dev/setup-worktree.sh ../ffworkspace-wt/asset-mgmt feature/asset-management

  # 使用 link 模式（不隔离端口）
  bash scripts/dev/setup-worktree.sh ../ffworkspace-wt/hotfix bugfix/login develop link
EOF
}

if [[ $# -lt 2 ]]; then
  usage
  exit 1
fi

WORKTREE_PATH="$1"
BRANCH_NAME="$2"
BASE_BRANCH="${3:-develop}"
ENV_MODE="${4:-copy}"

if [[ "${ENV_MODE}" != "link" && "${ENV_MODE}" != "copy" ]]; then
  echo "setup-worktree: env-mode 只支持 link 或 copy" >&2
  exit 1
fi

ROOT_DIR="$(git rev-parse --show-toplevel)"
CURRENT_BRANCH="$(git -C "${ROOT_DIR}" branch --show-current)"

# shellcheck source=../lib/pg-bootstrap.sh
source "${ROOT_DIR}/scripts/lib/pg-bootstrap.sh"

# 拉取最新远端信息
git -C "${ROOT_DIR}" fetch origin --prune >/dev/null 2>&1 || true

# 判断分支是否已存在（本地或远端）
BRANCH_EXISTS_LOCAL=false
BRANCH_EXISTS_REMOTE=false

if git -C "${ROOT_DIR}" show-ref --verify --quiet "refs/heads/${BRANCH_NAME}"; then
  BRANCH_EXISTS_LOCAL=true
fi
if git -C "${ROOT_DIR}" show-ref --verify --quiet "refs/remotes/origin/${BRANCH_NAME}"; then
  BRANCH_EXISTS_REMOTE=true
fi

# 创建 worktree
if [[ "${BRANCH_EXISTS_LOCAL}" == "true" ]]; then
  # 本地分支已存在，直接检出
  git -C "${ROOT_DIR}" worktree add "${WORKTREE_PATH}" "${BRANCH_NAME}"
  echo "setup-worktree: 检出已有本地分支: ${BRANCH_NAME}"
elif [[ "${BRANCH_EXISTS_REMOTE}" == "true" ]]; then
  # 远端分支存在，创建本地跟踪分支
  git -C "${ROOT_DIR}" worktree add "${WORKTREE_PATH}" -b "${BRANCH_NAME}" "origin/${BRANCH_NAME}"
  git -C "${WORKTREE_PATH}" branch --set-upstream-to="origin/${BRANCH_NAME}" "${BRANCH_NAME}"
  echo "setup-worktree: 检出远端分支: origin/${BRANCH_NAME}"
else
  # 全新分支，从 base-branch 创建
  BASE_REF="${BASE_BRANCH}"
  if git -C "${ROOT_DIR}" show-ref --verify --quiet "refs/remotes/origin/${BASE_BRANCH}"; then
    BASE_REF="origin/${BASE_BRANCH}"
  fi
  git -C "${ROOT_DIR}" worktree add -b "${BRANCH_NAME}" "${WORKTREE_PATH}" "${BASE_REF}"
  echo "setup-worktree: 创建新分支: ${BRANCH_NAME} (基于 ${BASE_REF})"
fi

# ==================== 环境变量配置 ====================

# 仅当 key 已存在时更新；key 缺失时静默 no-op（用于改源 .env 既有的端口/库名等）
set_env_value() {
  local file="$1"
  local key="$2"
  local value="$3"

  if [[ ! -f "${file}" ]]; then
    return 0
  fi

  if grep -qE "^${key}=" "${file}"; then
    sed -i -E "s|^(${key}=)[^#[:space:]]*([[:space:]]*#.*)?$|\\1${value}\\2|" "${file}"
  fi
}

# key 不存在时追加，存在时更新（用于补齐源 .env 缺失的 key，如 SHARED_CHECKIN_SECRET）
# vs set_env_value：选 ensure 当你需要"无论原文件有没有这条都得有"
ensure_env_value() {
  local file="$1"
  local key="$2"
  local value="$3"

  if [[ ! -f "${file}" ]]; then
    return 0
  fi

  if grep -qE "^${key}=" "${file}"; then
    sed -i -E "s|^(${key}=).*$|\\1${value}|" "${file}"
  else
    printf "\n%s=%s\n" "${key}" "${value}" >> "${file}"
  fi
}

replace_port_in_file() {
  local file="$1"
  local old_port="$2"
  local new_port="$3"

  if [[ ! -f "${file}" || -z "${old_port}" ]]; then
    return 0
  fi

  sed -i -E "s#:${old_port}([^0-9]|$)#:${new_port}\\1#g" "${file}"
}

find_next_port_slot() {
  local used_slots=""
  local worktree_path=""
  local env_file=""
  local frontend_port=""
  local slot=""

  while IFS= read -r line; do
    if [[ "${line}" == worktree\ * ]]; then
      worktree_path="${line#worktree }"
      env_file="${worktree_path}/.env"

      if [[ -f "${env_file}" ]]; then
        frontend_port="$(awk -F= '/^FRONTEND_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
        if [[ "${frontend_port}" =~ ^[0-9]{4,5}$ ]] && (( frontend_port % 100 == 0 )); then
          slot=$(( frontend_port / 100 ))
          used_slots="${used_slots} ${slot} "
        fi
      fi
    fi
  done < <(git -C "${ROOT_DIR}" worktree list --porcelain)

  # 收集额外的 orphan 来源（worktree 已删 / git list 缺失，但容器还在）：
  #   1. 当前 listening 端口
  #   2. ffws-wt-pg-<port> 容器名（标准 PG 命名，可被 setup_database 唤醒）
  #   3. 容器端口映射（覆盖 ffoa-wt-* 老 Redis 命名 / 任何用 host port 跑的容器）
  local listening_ports
  listening_ports="$(ss -tlnH 2>/dev/null | awk '{print $4}' | awk -F: '{print $NF}' | sort -u)"
  local container_pg_ports
  container_pg_ports="$(docker ps -a --format '{{.Names}}' 2>/dev/null \
    | sed -n 's/^ffws-wt-pg-\([0-9]\+\)$/\1/p' | sort -u)"
  # docker port mapping: 0.0.0.0:3303->6379/tcp 这种，提取 host 侧端口
  local container_host_ports
  container_host_ports="$(docker ps -a --format '{{.Ports}}' 2>/dev/null \
    | grep -oE '[0-9]+(\.[0-9]+){3}:[0-9]+|:::[0-9]+' \
    | awk -F: '{print $NF}' | sort -u)"

  for slot in $(seq 31 89); do
    if [[ "${used_slots}" == *" ${slot} "* ]]; then
      continue
    fi
    local fe=$(( slot * 100 ))
    local be=$(( slot * 100 + 1 ))
    local pg=$(( slot * 100 + 2 ))
    local rd=$(( slot * 100 + 3 ))
    if echo "${listening_ports}" | grep -qxE "${fe}|${be}|${pg}|${rd}"; then
      continue
    fi
    if echo "${container_pg_ports}" | grep -qx "${pg}"; then
      continue
    fi
    # Redis / 其它服务被任意命名的容器占着 host 端口（覆盖 ffoa-wt-*-redis 老遗留）
    if echo "${container_host_ports}" | grep -qxE "${fe}|${be}|${pg}|${rd}"; then
      continue
    fi
    echo "${slot}"
    return 0
  done

  echo "setup-worktree: 没有可用的 worktree 端口段（31xx-89xx）" >&2
  exit 1
}

configure_isolated_env() {
  local env_file="$1"
  local slot="$2"
  local frontend_port=$(( slot * 100 ))
  local backend_port=$(( slot * 100 + 1 ))
  local postgres_port=$(( slot * 100 + 2 ))
  local redis_port=$(( slot * 100 + 3 ))
  local temporal_grpc_port=$(( slot * 100 + 33 ))
  local temporal_http_port=$(( slot * 100 + 34 ))
  local temporal_ui_port=$(( slot * 100 + 80 ))
  local redis_commander_port=$(( slot * 100 + 81 ))
  local minio_api_port=$(( slot * 100 + 90 ))
  local minio_console_port=$(( slot * 100 + 91 ))
  local old_frontend_port=""
  local old_backend_port=""
  local old_postgres_port=""
  local old_redis_port=""
  local old_temporal_grpc_port=""

  if [[ ! -f "${env_file}" ]]; then
    return 0
  fi

  old_backend_port="$(awk -F= '/^BACKEND_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  old_frontend_port="$(awk -F= '/^FRONTEND_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  old_postgres_port="$(awk -F= '/^POSTGRES_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  old_redis_port="$(awk -F= '/^REDIS_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  old_temporal_grpc_port="$(awk -F= '/^TEMPORAL_GRPC_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"

  set_env_value "${env_file}" "FRONTEND_PORT" "${frontend_port}"
  set_env_value "${env_file}" "BACKEND_PORT" "${backend_port}"
  set_env_value "${env_file}" "POSTGRES_PORT" "${postgres_port}"
  set_env_value "${env_file}" "REDIS_PORT" "${redis_port}"
  set_env_value "${env_file}" "TEMPORAL_GRPC_PORT" "${temporal_grpc_port}"
  set_env_value "${env_file}" "TEMPORAL_HTTP_PORT" "${temporal_http_port}"
  set_env_value "${env_file}" "TEMPORAL_UI_PORT" "${temporal_ui_port}"
  set_env_value "${env_file}" "REDIS_COMMANDER_PORT" "${redis_commander_port}"
  set_env_value "${env_file}" "MINIO_API_PORT" "${minio_api_port}"
  set_env_value "${env_file}" "MINIO_CONSOLE_PORT" "${minio_console_port}"

  replace_port_in_file "${env_file}" "${old_frontend_port}" "${frontend_port}"
  replace_port_in_file "${env_file}" "${old_backend_port}" "${backend_port}"
  replace_port_in_file "${env_file}" "${old_postgres_port}" "${postgres_port}"
  replace_port_in_file "${env_file}" "${old_redis_port}" "${redis_port}"
  replace_port_in_file "${env_file}" "${old_temporal_grpc_port}" "${temporal_grpc_port}"

  # 配置独立数据库名
  local short_name
  short_name="$(basename "${WORKTREE_PATH}" | tr '-' '_')"
  local db_name="ffws_wt_${short_name}"
  set_env_value "${env_file}" "POSTGRES_DB" "${db_name}"
  # 替换 DATABASE_URL 中的数据库名
  if grep -qE "^DATABASE_URL=" "${env_file}"; then
    sed -i -E "s|(DATABASE_URL=.*/)([^?]+)(\?.*)|\1${db_name}\3|" "${env_file}"
  fi

  # 补齐 v1.5 共享签到必需的 env（源 .env 不带这两个 key，缺失会导致 QR token 类接口 500）
  if ! grep -qE "^SHARED_CHECKIN_SECRET=" "${env_file}" || \
     [[ -z "$(awk -F= '/^SHARED_CHECKIN_SECRET=/{print $2}' "${env_file}")" ]]; then
    ensure_env_value "${env_file}" "SHARED_CHECKIN_SECRET" "$(openssl rand -hex 32)"
  fi
  ensure_env_value "${env_file}" "SHARED_CHECKIN_ALLOWED_HOSTS" "localhost"
}

setup_database() {
  local env_file="${WORKTREE_PATH}/.env"
  if [[ ! -f "${env_file}" ]]; then
    return 0
  fi

  local postgres_port
  postgres_port="$(awk -F= '/^POSTGRES_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  local db_name
  db_name="$(awk -F= '/^POSTGRES_DB=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  local db_user
  db_user="$(awk -F= '/^POSTGRES_USER=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  local db_password
  db_password="$(awk -F= '/^POSTGRES_PASSWORD=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  local redis_port
  redis_port="$(awk -F= '/^REDIS_PORT=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"
  local redis_password
  redis_password="$(awk -F= '/^REDIS_PASSWORD=/{gsub(/[[:space:]]|#.*/, "", $2); print $2; exit}' "${env_file}")"

  local container_name="ffws-wt-pg-${postgres_port}"
  local redis_container="ffws-wt-redis-${redis_port}"

  # 检查是否已有该端口的容器
  if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
    echo "setup-worktree: PostgreSQL 容器已存在: ${container_name}"
    if ! docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
      docker start "${container_name}"
      echo "setup-worktree: 已启动停止的容器: ${container_name}"
    fi
  else
    echo "setup-worktree: 创建独立 PostgreSQL 容器: ${container_name} (端口 ${postgres_port})"
    docker run -d \
      --name "${container_name}" \
      -p "${postgres_port}:5432" \
      -e "POSTGRES_DB=${db_name}" \
      -e "POSTGRES_USER=${db_user}" \
      -e "POSTGRES_PASSWORD=${db_password}" \
      --restart unless-stopped \
      postgres:16-alpine
  fi

  # 等待数据库就绪 + 安装扩展（必须在 prisma db push 之前；否则 schema 里 @db.Citext
  # 等类型会报 type "xxx" does not exist）。新增扩展直接往下面数组加。
  # 实现委托 scripts/lib/pg-bootstrap.sh（issue #312）。
  PG_BOOTSTRAP_LOG_PREFIX="setup-worktree" \
    wait_for_pg_container "${container_name}" "${db_user}" "" 30 || true

  local PG_EXTENSIONS=(citext)
  PG_BOOTSTRAP_LOG_PREFIX="setup-worktree" \
    ensure_pg_extensions "${container_name}" "${db_user}" "${db_name}" "${db_password}" "${PG_EXTENSIONS[@]}" || true

  # Redis 容器（IAM 模块硬依赖 Redis，没起来后端启动后会刷 ECONNREFUSED）
  if [[ -n "${redis_port}" ]]; then
    if docker ps -a --format '{{.Names}}' | grep -q "^${redis_container}$"; then
      if ! docker ps --format '{{.Names}}' | grep -q "^${redis_container}$"; then
        docker start "${redis_container}" >/dev/null
        echo "setup-worktree: 已启动停止的 Redis 容器: ${redis_container}"
      else
        echo "setup-worktree: Redis 容器已运行: ${redis_container}"
      fi
    else
      echo "setup-worktree: 创建 Redis 容器: ${redis_container} (端口 ${redis_port})"
      if [[ -n "${redis_password}" ]]; then
        docker run -d \
          --name "${redis_container}" \
          -p "${redis_port}:6379" \
          --restart unless-stopped \
          redis:7-alpine redis-server --requirepass "${redis_password}" >/dev/null
      else
        docker run -d \
          --name "${redis_container}" \
          -p "${redis_port}:6379" \
          --restart unless-stopped \
          redis:7-alpine >/dev/null
      fi
    fi
  fi

  # 安装依赖（prisma 需要 node_modules 才能运行）
  echo "setup-worktree: 安装依赖..."
  (cd "${WORKTREE_PATH}" && npm run install:all 2>&1 | tail -3)

  # 初始化数据库 schema
  echo "setup-worktree: 初始化数据库 schema..."
  (cd "${WORKTREE_PATH}/backend" && npx dotenv -e .env -- npx prisma db push --accept-data-loss 2>&1 | tail -3)

  # 灌种子数据（角色/权限/AI grants）+ 创建 itadmin 登录账号
  # CLAUDE.md 误标 db:seed 包含 itadmin，实测不会，必须独立跑 init:itadmin
  echo "setup-worktree: 灌种子数据..."
  (cd "${WORKTREE_PATH}/backend" && npm run db:seed 2>&1 | tail -3) || \
    echo "setup-worktree: ⚠️  db:seed 失败，新 worktree 角色/权限可能为空"
  echo "setup-worktree: 创建 itadmin 账号..."
  (cd "${WORKTREE_PATH}/backend" && npm run init:itadmin 2>&1 | tail -5) || \
    echo "setup-worktree: ⚠️  init:itadmin 失败，请手动 'cd backend && npm run init:itadmin'"
}

# ==================== 执行环境配置 ====================

sync_env_file() {
  local source_file="$1"
  local target_file="$2"

  if [[ ! -e "${source_file}" ]]; then
    return 0
  fi

  mkdir -p "$(dirname "${target_file}")"

  if [[ "${ENV_MODE}" == "link" ]]; then
    ln -sfn "${source_file}" "${target_file}"
  else
    cp "${source_file}" "${target_file}"
  fi
}

sync_child_env() {
  local child_dir="$1"
  local target_dir="${WORKTREE_PATH}/${child_dir}"
  local target_file="${target_dir}/.env"

  if [[ ! -d "${target_dir}" ]]; then
    return 0
  fi

  if [[ "${ENV_MODE}" == "link" ]]; then
    ln -sfn "../.env" "${target_file}"
  else
    cp "${WORKTREE_PATH}/.env" "${target_file}"
  fi
}

# 同步环境文件
sync_env_file "${ROOT_DIR}/.env" "${WORKTREE_PATH}/.env"
sync_env_file "${ROOT_DIR}/.env.dev" "${WORKTREE_PATH}/.env.dev"

# 配置独立端口和数据库
PORT_SLOT=""
if [[ "${ENV_MODE}" == "copy" ]]; then
  PORT_SLOT="$(find_next_port_slot)"
  configure_isolated_env "${WORKTREE_PATH}/.env" "${PORT_SLOT}"
  configure_isolated_env "${WORKTREE_PATH}/.env.dev" "${PORT_SLOT}"
fi

# 同步子目录环境文件
sync_child_env "backend"
sync_child_env "frontend"
sync_child_env "docker"

# 配置 git hooks
git -C "${WORKTREE_PATH}" config core.hooksPath .githooks

# 创建独立数据库实例
if [[ "${ENV_MODE}" == "copy" ]]; then
  setup_database
fi

# ==================== 生成 TASK.md ====================

generate_task_md() {
  local task_file="${WORKTREE_PATH}/TASK.md"

  if [[ -f "${task_file}" ]]; then
    return 0
  fi

  local port_line=""
  if [[ -n "${PORT_SLOT}" ]]; then
    port_line="端口：前端 $(( PORT_SLOT * 100 )) · 后端 $(( PORT_SLOT * 100 + 1 )) · 数据库 $(( PORT_SLOT * 100 + 2 ))"
  fi

  cat > "${task_file}" <<TASKEOF
# 任务：${BRANCH_NAME}

## 背景
<!-- 描述这个分支要解决的问题或实现的需求 -->

## 目标
<!-- 明确的交付目标 -->

## 工作步骤
- [ ] 补充/更新文档
- [ ] schema 变更（如涉及）
- [ ] 后端实现
- [ ] 前端实现
- [ ] 测试（L0→L1→L2）
- [ ] 提交 PR

## 启动开发服务器

\`\`\`bash
cd ${WORKTREE_PATH}
npm run dev
\`\`\`

${port_line}
TASKEOF

  echo "setup-worktree: 已生成 TASK.md（本地文件，不入库）"
}

if [[ "${ENV_MODE}" == "copy" ]]; then
  generate_task_md
fi

# ==================== 可选：Caddy 域名映射（个人配置） ====================
# 详见：docs/standards/05-development-workflow.md「可选：Caddy 域名映射」

WORKTREE_DOMAIN=""
if [[ -n "${FFOA_DEV_DOMAIN_BASE:-}" && "${ENV_MODE}" == "copy" ]]; then
  setup_caddy_domain() {
    local caddy_file="${FFOA_DEV_CADDY_FILE:-}"
    local reload_cmd="${FFOA_DEV_CADDY_RELOAD_CMD:-}"
    if [[ -z "${caddy_file}" || ! -w "${caddy_file}" ]]; then
      echo "setup-worktree: ⚠️  FFOA_DEV_DOMAIN_BASE 已设但 FFOA_DEV_CADDY_FILE 未设或不可写，跳过域名注入"
      return 0
    fi
    local short_name
    short_name="$(basename "${WORKTREE_PATH}")"
    local domain="${short_name}.${USER}.${FFOA_DEV_DOMAIN_BASE}"
    local fe=$(( PORT_SLOT * 100 ))
    local be=$(( PORT_SLOT * 100 + 1 ))
    local marker_begin="# >>> ffoa-worktree:${short_name}:${USER} >>>"
    local marker_end="# <<< ffoa-worktree:${short_name}:${USER} <<<"

    # 同名块已存在则先剔除（幂等）
    if grep -qF "${marker_begin}" "${caddy_file}"; then
      sed -i "/${marker_begin//\//\\/}/,/${marker_end//\//\\/}/d" "${caddy_file}"
    fi

    cat >> "${caddy_file}" <<CADDYEOF

${marker_begin}
${domain} {
    handle /api/* {
        reverse_proxy host.docker.internal:${be}
    }
    handle /health* {
        reverse_proxy host.docker.internal:${be}
    }
    handle {
        reverse_proxy host.docker.internal:${fe}
    }
}
${marker_end}
CADDYEOF

    if [[ -n "${reload_cmd}" ]]; then
      if eval "${reload_cmd}" >/dev/null 2>&1; then
        echo "setup-worktree: Caddy 已 reload"
      else
        echo "setup-worktree: ⚠️  Caddy reload 失败，请手动执行: ${reload_cmd}"
      fi
    fi

    # 改写 worktree 三个 .env 让前端 API 调用 / CORS / 共享签到白名单都走公网域名
    # 否则浏览器从 https://<domain> 加载页面后 API 调用回 localhost → ERR_CONNECTION_REFUSED
    local fe_port=$(( PORT_SLOT * 100 ))
    for f in "${WORKTREE_PATH}/.env" "${WORKTREE_PATH}/backend/.env" "${WORKTREE_PATH}/frontend/.env"; do
      [[ -f "${f}" ]] || continue
      sed -i "s|^NEXT_PUBLIC_API_URL=.*|NEXT_PUBLIC_API_URL=https://${domain}/api/v1|" "${f}"
      sed -i "s|^CORS_ORIGIN=.*|CORS_ORIGIN=https://${domain},http://localhost:${fe_port}|" "${f}"
      sed -i "s|^SHARED_CHECKIN_ALLOWED_HOSTS=.*|SHARED_CHECKIN_ALLOWED_HOSTS=${domain},localhost|" "${f}"
    done

    WORKTREE_DOMAIN="${domain}"
    echo "setup-worktree: 域名映射已注入: https://${domain}"
  }
  setup_caddy_domain
fi

# ==================== 输出结果 ====================

cat <<EOF

╔═══════════════════════════════════════════════════════════╗
║  worktree 已创建完成                                      ║
╚═══════════════════════════════════════════════════════════╝

  分支:         ${BRANCH_NAME}
  目录:         ${WORKTREE_PATH}
  环境变量模式: ${ENV_MODE}
EOF

if [[ -n "${PORT_SLOT}" ]]; then
  cat <<EOF
  端口段:       ${PORT_SLOT}xx
  前端端口:     $(( PORT_SLOT * 100 ))
  后端端口:     $(( PORT_SLOT * 100 + 1 ))
  数据库端口:   $(( PORT_SLOT * 100 + 2 ))

  后续步骤:
    cd ${WORKTREE_PATH}
    npm run dev               # 启动开发服务器
EOF
fi

if [[ -n "${WORKTREE_DOMAIN}" ]]; then
  cat <<EOF

  🌐 公网访问:   https://${WORKTREE_DOMAIN}
                 （首次访问可能需几秒等待 Caddy 自动签发 TLS 证书）
EOF
fi