FranklinWH-Toolbox/deploy/scripts/setup.sh

#!/usr/bin/env bash
# =============================================================================
# FranklinWH Toolbox - 交互式一键部署脚本
# =============================================================================
# 特性：
#   * 分步交互：逐项选择/填写，回车即用默认值
#   * 支持两种目标：
#       1) local  —— 在当前主机部署
#       2) remote —— 通过 SSH 部署到远程主机（自动打包并传输构建产物）
#   * 可选步骤：初始化数据库 / 部署后端 / 部署前端
#   * 自动根据填写内容生成 config.env
#
# 依赖：
#   本机需有 bash、ssh、scp、tar；构建前端/后端需 pnpm、go（仅在“构建”步骤需要）
#
# 用法：
#   ./setup.sh                 # 进入交互式向导
#   ./setup.sh --help
#
# 说明：
#   远程部署采用“本地构建 + 远程安装”策略：前端 dist 与后端二进制在本机构建后
#   打包上传到远程，再由远程执行安装脚本，避免远程主机必须装 Go/Node。
#   数据库软件的安装请参考 deploy/DEPLOYMENT.md 第 3、4 章，本脚本只做
#   建库建表建桶与服务部署，不自动安装数据库引擎。
# =============================================================================
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DEPLOY_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"           # deploy/
PROJECT_ROOT="$(cd "${DEPLOY_DIR}/.." && pwd)"         # 仓库根目录
SERVICE_DIR="${PROJECT_ROOT}/service"
SQL_FILE="${DEPLOY_DIR}/sql/init_pgsql.sql"
CONFIG_EXAMPLE="${DEPLOY_DIR}/config.env.example"

APP_NAME="fwh-toolbox-server"
MCP_NAME="fwh-mcp-server"

# ---------------------------------------------------------------------------
# 输出辅助
# ---------------------------------------------------------------------------
c_reset='\033[0m'; c_blue='\033[1;34m'; c_green='\033[1;32m'; c_yellow='\033[1;33m'; c_red='\033[1;31m'; c_bold='\033[1m'
info()  { echo -e "${c_blue}[INFO]${c_reset} $*"; }
ok()    { echo -e "${c_green}[ OK ]${c_reset} $*"; }
warn()  { echo -e "${c_yellow}[WARN]${c_reset} $*"; }
err()   { echo -e "${c_red}[FAIL]${c_reset} $*" >&2; }
title() { echo -e "\n${c_bold}==== $* ====${c_reset}"; }

# 提示输入（带默认值）：ask VAR "提示" "默认值"
ask() {
    local __var="$1" __prompt="$2" __default="${3:-}" __ans
    if [[ -n "${__default}" ]]; then
        read -r -p "$(echo -e "${c_bold}${__prompt}${c_reset} [${__default}]: ")" __ans
        __ans="${__ans:-${__default}}"
    else
        read -r -p "$(echo -e "${c_bold}${__prompt}${c_reset}: ")" __ans
    fi
    printf -v "${__var}" '%s' "${__ans}"
}

# 提示输入密码（不回显）：ask_secret VAR "提示" "默认值"
ask_secret() {
    local __var="$1" __prompt="$2" __default="${3:-}" __ans
    read -r -s -p "$(echo -e "${c_bold}${__prompt}${c_reset}${__default:+ [回车用默认]}: ")" __ans
    echo
    __ans="${__ans:-${__default}}"
    printf -v "${__var}" '%s' "${__ans}"
}

# 是/否确认：ask_yn "提示" "y|n(默认)"  -> 返回 0=yes 1=no
ask_yn() {
    local __prompt="$1" __default="${2:-y}" __ans
    local __hint="[Y/n]"; [[ "${__default}" == "n" ]] && __hint="[y/N]"
    read -r -p "$(echo -e "${c_bold}${__prompt}${c_reset} ${__hint}: ")" __ans
    __ans="${__ans:-${__default}}"
    [[ "${__ans}" =~ ^[Yy]$ ]]
}

require_cmd() {
    command -v "$1" >/dev/null 2>&1 || { err "缺少命令：$1（$2）"; return 1; }
}

# ---------------------------------------------------------------------------
# 全局变量（向导填写）
# ---------------------------------------------------------------------------
MODE=""                 # local | remote
DO_DEPS="y"; DO_CASDOOR="n"; DO_INITDB="y"; DO_BACKEND="y"; DO_FRONTEND="y"; DO_GENCONF="y"; DO_CADDY="n"; DO_KIRO="n"

# 远程连接
R_HOST=""; R_PORT="22"; R_USER=""; R_SSH_KEY=""

# 部署目录
DEPLOY_ROOT="/var/www/fwh-toolbox"
RUN_USER=""

# 数据库/配置项
# TODO: 以下均为“默认值”，向导会逐项提示你确认或覆盖。以下几项默认口令不安全，
#       运行向导时务必改为强口令：PG_PASS、MINIO_ROOT_PASSWORD、CASDOOR_PG_PASSWORD；
#       并按需填写 MINIO_ACCESS_KEY/MINIO_SECRET_KEY、MYSQL_DSN、CASDOOR_ORIGIN。
APP_ENV="dev"; APP_PORT="8301"; ASYNQMON_PORT="8302"
PG_HOST="localhost"; PG_PORT="5432"; PG_DB="fwh_toolbox_db"; PG_USER="fwh_toolbox"; PG_PASS="fwh_toolbox"  # TODO: [必填] PG_PASS 改强口令
MONGO_DSN="mongodb://127.0.0.1:27017/FwhToolboxDb"
REDIS_ADDR="localhost:6379"
MYSQL_DSN=""                                              # TODO: [必填/可选] 远端只读 MySQL DSN，用到站点查询才需填
MINIO_ENDPOINT="localhost:9198"; MINIO_ACCESS_KEY=""; MINIO_SECRET_KEY=""; MINIO_BUCKET="fwh-toolbox"  # TODO: [必填] MinIO AK/SK
MINIO_ROOT_USER="minioadmin"; MINIO_ROOT_PASSWORD="minioadmin"  # TODO: [必填] MinIO 管理员改强口令

# Casdoor
CASDOOR_DIR=""; CASDOOR_PORT="8010"
CASDOOR_PG_USER="casdoor"; CASDOOR_PG_PASSWORD="casdoor"; CASDOOR_DB_NAME="casdoor"  # TODO: [必填] CASDOOR_PG_PASSWORD 改强口令
CASDOOR_ORIGIN=""                                         # TODO: [必填] Casdoor 对外访问地址，如 https://<域名>/casdoor

# Caddy 反向代理
CADDY_DOMAIN=""                                          # TODO: [必填] 对外域名，如 lmt.zenpower.cc
CADDY_TLS_MODE="internal"                                # internal | acme | manual
CADDY_ACME_EMAIL=""                                      # acme 模式邮箱（可空，走默认 ACME）
CADDY_TLS_CERT=""; CADDY_TLS_KEY=""                      # manual 模式证书/私钥路径
CADDY_FRONTEND_PORT="8300"; CADDY_BACKEND_PORT="8301"
CADDY_INCLUDE_CASDOOR="n"; CADDY_INCLUDE_MINIO="n"
CADDY_SERVE_STATIC="n"                                   # 由 Caddy 直接 file_server 托管前端

# Kiro CLI（后端 AI 对话依赖）
KIRO_INSTALL_METHOD="zip"                                # zip | curl
KIRO_LIBC="gnu"                                          # gnu | musl
KIRO_DO_LOGIN="n"                                        # 安装后是否立即交互式登录

# 生成的配置文件（本地临时路径）
GEN_CONFIG=""

# ---------------------------------------------------------------------------
# 步骤 0：选择模式与步骤
# ---------------------------------------------------------------------------
wizard_intro() {
    title "FranklinWH Toolbox 交互式部署向导"
    echo "本向导将分步引导你完成部署。任何提示都可直接回车使用默认值。"
    echo
    echo "请选择部署目标："
    echo "  1) 本地部署 (local)"
    echo "  2) 远程部署 (remote, 通过 SSH)"
    local sel; ask sel "输入序号" "1"
    case "${sel}" in
        1) MODE="local" ;;
        2) MODE="remote" ;;
        *) err "无效选择"; exit 1 ;;
    esac
    ok "部署模式：${MODE}"

    title "选择要执行的步骤"
    ask_yn "① 检测/安装数据库引擎与依赖（PostgreSQL/Mongo/Redis/MinIO/Docker）？" "y" && DO_DEPS="y" || DO_DEPS="n"
    ask_yn "② 安装 Casdoor（Docker，认证服务）？" "n" && DO_CASDOOR="y" || DO_CASDOOR="n"
    ask_yn "③ 初始化数据库（建库/建表/建桶）？" "y" && DO_INITDB="y" || DO_INITDB="n"
    ask_yn "④ 部署后端（构建二进制 + systemd 服务）？" "y" && DO_BACKEND="y" || DO_BACKEND="n"
    ask_yn "⑤ 部署前端（构建 dist + 同步静态目录）？" "y" && DO_FRONTEND="y" || DO_FRONTEND="n"
    if [[ "${DO_BACKEND}" == "y" || "${DO_INITDB}" == "y" ]]; then
        ask_yn "⑥ 生成 config.env（根据后续填写内容）？" "y" && DO_GENCONF="y" || DO_GENCONF="n"
    else
        DO_GENCONF="n"
    fi
    ask_yn "⑦ 安装并配置 Caddy 反向代理（生成站点 Caddyfile 并 reload）？" "n" && DO_CADDY="y" || DO_CADDY="n"
    ask_yn "⑧ 安装 Kiro CLI（后端 AI 对话依赖，需以运行用户登录 Builder ID）？" "n" && DO_KIRO="y" || DO_KIRO="n"
}

# ---------------------------------------------------------------------------
# 步骤 1：远程连接信息
# ---------------------------------------------------------------------------
wizard_remote() {
    [[ "${MODE}" == "remote" ]] || return 0
    title "远程主机连接信息"
    ask R_HOST "远程主机地址 (IP 或域名)"
    [[ -n "${R_HOST}" ]] || { err "远程地址不能为空"; exit 1; }
    ask R_PORT "SSH 端口" "22"
    ask R_USER "SSH 登录用户" "${USER}"
    ask R_SSH_KEY "SSH 私钥路径（留空则用默认/密码）" ""

    info "测试 SSH 连接 ..."
    if ssh_run "echo connected" >/dev/null 2>&1; then
        ok "SSH 连接成功"
    else
        err "SSH 连接失败，请检查地址/端口/用户/密钥"
        exit 1
    fi
}

# 组装 ssh/scp 通用参数
ssh_opts() {
    local opts=(-p "${R_PORT}" -o StrictHostKeyChecking=accept-new)
    [[ -n "${R_SSH_KEY}" ]] && opts+=(-i "${R_SSH_KEY}")
    printf '%s\n' "${opts[@]}"
}
scp_opts() {
    local opts=(-P "${R_PORT}" -o StrictHostKeyChecking=accept-new)
    [[ -n "${R_SSH_KEY}" ]] && opts+=(-i "${R_SSH_KEY}")
    printf '%s\n' "${opts[@]}"
}
# 在远程执行命令
ssh_run() {
    mapfile -t _o < <(ssh_opts)
    ssh "${_o[@]}" "${R_USER}@${R_HOST}" "$@"
}
# 拷贝文件/目录到远程
scp_to() {
    mapfile -t _o < <(scp_opts)
    scp "${_o[@]}" -r "$1" "${R_USER}@${R_HOST}:$2"
}

# 统一执行命令封装：本地直接跑，远程走 ssh
run() {
    if [[ "${MODE}" == "remote" ]]; then
        ssh_run "$@"
    else
        bash -c "$@"
    fi
}

# ---------------------------------------------------------------------------
# 步骤 2：部署参数与配置项
# ---------------------------------------------------------------------------
wizard_params() {
    title "部署目录与运行用户"
    ask DEPLOY_ROOT "部署根目录" "/var/www/fwh-toolbox"
    local def_user="${R_USER:-${USER}}"
    ask RUN_USER "后端 systemd 运行用户" "${def_user}"

    if [[ "${DO_GENCONF}" == "y" ]]; then
        title "应用配置"
        ask APP_ENV "运行环境 (pro/dev)" "dev"
        ask APP_PORT "后端监听端口" "8301"
        ask ASYNQMON_PORT "Asynqmon 端口" "8302"

        title "PostgreSQL（本地）"
        ask PG_HOST "PG 主机" "localhost"
        ask PG_PORT "PG 端口" "5432"
        ask PG_DB   "PG 数据库名" "fwh_toolbox_db"
        ask PG_USER "PG 业务角色" "fwh_toolbox"
        ask_secret PG_PASS "PG 业务角色密码" "fwh_toolbox"

        title "MongoDB / Redis"
        ask MONGO_DSN "Mongo 连接串" "mongodb://127.0.0.1:27017/FwhToolboxDb"
        ask REDIS_ADDR "Redis 地址" "localhost:6379"

        title "远端只读 MySQL（FWH 生产库，可留空跳过）"
        ask MYSQL_DSN "MySQL DSN" ""

        title "MinIO（本地对象存储）"
        ask MINIO_ENDPOINT "MinIO S3 API 地址" "localhost:9198"
        ask MINIO_ACCESS_KEY "MinIO Access Key" "fwh-toolbox"
        ask_secret MINIO_SECRET_KEY "MinIO Secret Key" "fwh-toolbox"
        ask MINIO_BUCKET "MinIO Bucket 名" "fwh-toolbox"
    fi

    if [[ "${DO_INITDB}" == "y" || "${DO_DEPS}" == "y" ]]; then
        title "MinIO 管理员账户（安装/建桶用）"
        ask MINIO_ROOT_USER "MinIO 管理员用户" "minioadmin"
        ask_secret MINIO_ROOT_PASSWORD "MinIO 管理员密码" "minioadmin"
    fi

    if [[ "${DO_CASDOOR}" == "y" ]]; then
        title "Casdoor（Docker 认证服务）"
        local def_cdir="/home/${RUN_USER}/docker/casdoor"
        ask CASDOOR_DIR "Casdoor 部署目录" "${def_cdir}"
        ask CASDOOR_PORT "Casdoor 对外端口 (->容器8000)" "8010"
        ask CASDOOR_PG_USER "Casdoor 使用的 PG 角色" "casdoor"
        ask_secret CASDOOR_PG_PASSWORD "Casdoor PG 角色密码" "casdoor"
        ask CASDOOR_DB_NAME "Casdoor 数据库名" "casdoor"
        ask CASDOOR_ORIGIN "Casdoor 对外访问地址(origin)" "http://localhost:${CASDOOR_PORT}"
    fi

    if [[ "${DO_CADDY}" == "y" ]]; then
        title "Caddy 反向代理"
        ask CADDY_DOMAIN "对外域名 (如 lmt.zenpower.cc)"
        [[ -n "${CADDY_DOMAIN}" ]] || { err "Caddy 域名不能为空"; exit 1; }
        echo "TLS 模式：1) internal(自签，测试)  2) acme(自动签发)  3) manual(指定证书)"
        local _tls_sel; ask _tls_sel "输入序号" "1"
        case "${_tls_sel}" in
            1) CADDY_TLS_MODE="internal" ;;
            2) CADDY_TLS_MODE="acme"; ask CADDY_ACME_EMAIL "ACME 邮箱（可留空走默认）" "" ;;
            3) CADDY_TLS_MODE="manual"
               ask CADDY_TLS_CERT "证书文件路径 (.pem/.crt)"
               ask CADDY_TLS_KEY  "私钥文件路径 (.key)" ;;
            *) err "无效选择"; exit 1 ;;
        esac
        ask CADDY_FRONTEND_PORT "前端静态端口" "8300"
        ask CADDY_BACKEND_PORT "后端 API 端口" "${APP_PORT}"
        ask_yn "由 Caddy 直接 file_server 托管前端静态（否则反代到前端端口）？" "n" \
            && CADDY_SERVE_STATIC="y" || CADDY_SERVE_STATIC="n"
        ask_yn "加入 /casdoor 反代？" "$( [[ ${DO_CASDOOR} == y ]] && echo y || echo n )" \
            && CADDY_INCLUDE_CASDOOR="y" || CADDY_INCLUDE_CASDOOR="n"
        ask_yn "加入 /fwh-minio (MinIO 控制台) 反代？" "n" \
            && CADDY_INCLUDE_MINIO="y" || CADDY_INCLUDE_MINIO="n"
    fi

    if [[ "${DO_KIRO}" == "y" ]]; then
        title "Kiro CLI（后端 AI 对话依赖）"
        echo "将以运行用户 ${RUN_USER} 身份安装（其 HOME 决定 ~/.kiro 配置位置）。"
        echo "安装方式：1) zip 官方安装包(默认)  2) curl 一键脚本"
        local _km; ask _km "输入序号" "1"
        case "${_km}" in
            1) KIRO_INSTALL_METHOD="zip"
               echo "C 库变体：1) gnu(默认，主流发行版)  2) musl(Alpine 等)"
               local _kl; ask _kl "输入序号" "1"
               [[ "${_kl}" == "2" ]] && KIRO_LIBC="musl" || KIRO_LIBC="gnu" ;;
            2) KIRO_INSTALL_METHOD="curl" ;;
            *) err "无效选择"; exit 1 ;;
        esac
        ask_yn "安装后立即以 ${RUN_USER} 身份登录 Builder ID（交互式，需浏览器）？" "n" \
            && KIRO_DO_LOGIN="y" || KIRO_DO_LOGIN="n"
    fi
}

# ---------------------------------------------------------------------------
# 生成 config.env（本地临时文件）
# ---------------------------------------------------------------------------
generate_config() {
    [[ "${DO_GENCONF}" == "y" ]] || return 0
    title "生成 config.env"
    GEN_CONFIG="$(mktemp /tmp/fwh_config.env.XXXXXX)"
    # 以模板为基础，替换关键项；未覆盖的项保留模板默认（含 FWH/Plane/MQTT 等）
    cp "${CONFIG_EXAMPLE}" "${GEN_CONFIG}"

    local pg_dsn="host=${PG_HOST} user=${PG_USER} password=${PG_PASS} dbname=${PG_DB} port=${PG_PORT} sslmode=disable"

    # 使用 python 做安全替换（避免特殊字符干扰 sed）
    if command -v python3 >/dev/null 2>&1; then
        APP_ENV="${APP_ENV}" APP_PORT="${APP_PORT}" ASYNQMON_PORT="${ASYNQMON_PORT}" \
        PG_DSN="${pg_dsn}" MONGO_DSN="${MONGO_DSN}" REDIS_ADDR="${REDIS_ADDR}" MYSQL_DSN="${MYSQL_DSN}" \
        MINIO_ENDPOINT="${MINIO_ENDPOINT}" MINIO_ACCESS_KEY="${MINIO_ACCESS_KEY}" \
        MINIO_SECRET_KEY="${MINIO_SECRET_KEY}" MINIO_BUCKET="${MINIO_BUCKET}" \
        RUN_USER="${RUN_USER}" \
        python3 - "${GEN_CONFIG}" <<'PY'
import os, re, sys
path = sys.argv[1]
repl = {
    "APP_ENV":            os.environ["APP_ENV"],
    "APP_PORT":           os.environ["APP_PORT"],
    "ASYNQMON_PORT":      os.environ["ASYNQMON_PORT"],
    "POSTGRES_DSN":       os.environ["PG_DSN"],
    "MONGO_DSN":          os.environ["MONGO_DSN"],
    "REDIS_ADDR":         os.environ["REDIS_ADDR"],
    "MINIO_ENDPOINT":     os.environ["MINIO_ENDPOINT"],
    "MINIO_ACCESS_KEY":   os.environ["MINIO_ACCESS_KEY"],
    "MINIO_SECRET_KEY":   os.environ["MINIO_SECRET_KEY"],
    "MINIO_BUCKET_NAME":  os.environ["MINIO_BUCKET"],
    "KIRO_RUN_AS_USER":   os.environ["RUN_USER"],
}
mysql = os.environ.get("MYSQL_DSN", "")
if mysql:
    repl["MYSQL_DSN"] = mysql

lines = open(path, encoding="utf-8").read().splitlines()
out = []
for line in lines:
    m = re.match(r'^(\s*)([A-Z0-9_]+)\s*=', line)
    if m and m.group(2) in repl:
        key = m.group(2)
        val = repl[key]
        # KIRO_RUN_AS_USER 模板里是无引号写法，其余用双引号包裹
        if key == "KIRO_RUN_AS_USER":
            out.append(f'{key}={val}')
        else:
            out.append(f'{key}="{val}"')
    else:
        out.append(line)
open(path, "w", encoding="utf-8").write("\n".join(out) + "\n")
print("config.env 已生成")
PY
    else
        warn "未找到 python3，改用 sed 简易替换（含特殊字符时请手工核对）"
        _sed_kv() { sed -i -E "s#^(${1})=.*#${1}=\"${2//#/\\#}\"#" "${GEN_CONFIG}"; }
        _sed_kv APP_ENV "${APP_ENV}"
        _sed_kv APP_PORT "${APP_PORT}"
        _sed_kv ASYNQMON_PORT "${ASYNQMON_PORT}"
        _sed_kv POSTGRES_DSN "${pg_dsn}"
        _sed_kv MONGO_DSN "${MONGO_DSN}"
        _sed_kv REDIS_ADDR "${REDIS_ADDR}"
        [[ -n "${MYSQL_DSN}" ]] && _sed_kv MYSQL_DSN "${MYSQL_DSN}"
        _sed_kv MINIO_ENDPOINT "${MINIO_ENDPOINT}"
        _sed_kv MINIO_ACCESS_KEY "${MINIO_ACCESS_KEY}"
        _sed_kv MINIO_SECRET_KEY "${MINIO_SECRET_KEY}"
        _sed_kv MINIO_BUCKET_NAME "${MINIO_BUCKET}"
        sed -i -E "s#^KIRO_RUN_AS_USER=.*#KIRO_RUN_AS_USER=${RUN_USER}#" "${GEN_CONFIG}"
    fi
    ok "已生成配置：${GEN_CONFIG}"
}

# ---------------------------------------------------------------------------
# 构建产物（前端 dist、后端二进制）——始终在本机构建
# ---------------------------------------------------------------------------
build_frontend() {
    [[ "${DO_FRONTEND}" == "y" ]] || return 0
    title "构建前端"
    require_cmd pnpm "安装 Node 22 + pnpm，见 DEPLOYMENT.md 3.3"
    ( cd "${PROJECT_ROOT}" && pnpm install --frozen-lockfile && pnpm build )
    ok "前端构建完成：${PROJECT_ROOT}/dist"
}

build_backend() {
    [[ "${DO_BACKEND}" == "y" ]] || return 0
    title "构建后端"
    require_cmd go "安装 Go 1.26，见 DEPLOYMENT.md 3.2"
    ( cd "${SERVICE_DIR}" \
        && GOOS=linux GOARCH=amd64 go build -o "${APP_NAME}" ./ \
        && GOOS=linux GOARCH=amd64 go build -o "${MCP_NAME}" ./cmd/mcp/ )
    ok "后端构建完成"
}

# ---------------------------------------------------------------------------
# 打包上传（远程模式）
# ---------------------------------------------------------------------------
REMOTE_STAGE="/tmp/fwh-deploy-stage"
prepare_remote_stage() {
    [[ "${MODE}" == "remote" ]] || return 0
    title "上传部署产物到远程"
    ssh_run "rm -rf ${REMOTE_STAGE} && mkdir -p ${REMOTE_STAGE}/sql ${REMOTE_STAGE}/cert ${REMOTE_STAGE}/scripts"
    # 辅助脚本（依赖安装/ Casdoor）
    scp_to "${SCRIPT_DIR}/install_deps.sh" "${REMOTE_STAGE}/scripts/"
    scp_to "${SCRIPT_DIR}/install_casdoor.sh" "${REMOTE_STAGE}/scripts/"
    scp_to "${SCRIPT_DIR}/install_caddy.sh" "${REMOTE_STAGE}/scripts/"
    scp_to "${SCRIPT_DIR}/install_kiro_cli.sh" "${REMOTE_STAGE}/scripts/"
    ssh_run "chmod +x ${REMOTE_STAGE}/scripts/*.sh"
    # SQL 与二进制、前端、配置、证书
    scp_to "${SQL_FILE}" "${REMOTE_STAGE}/sql/"
    if [[ "${DO_BACKEND}" == "y" ]]; then
        scp_to "${SERVICE_DIR}/${APP_NAME}" "${REMOTE_STAGE}/"
        scp_to "${SERVICE_DIR}/${MCP_NAME}" "${REMOTE_STAGE}/"
        # 证书目录（若存在）
        [[ -d "${SERVICE_DIR}/cert" ]] && scp_to "${SERVICE_DIR}/cert" "${REMOTE_STAGE}/"
    fi
    if [[ "${DO_FRONTEND}" == "y" ]]; then
        ( cd "${PROJECT_ROOT}" && tar czf /tmp/fwh-dist.tgz -C dist . )
        scp_to "/tmp/fwh-dist.tgz" "${REMOTE_STAGE}/"
        rm -f /tmp/fwh-dist.tgz
    fi
    [[ -n "${GEN_CONFIG}" ]] && scp_to "${GEN_CONFIG}" "${REMOTE_STAGE}/config.env"
    [[ -n "${GEN_CONFIG}" ]] && scp_to "${GEN_CONFIG}" "${REMOTE_STAGE}/config.mcp.env"
    ok "产物已上传到远程 ${REMOTE_STAGE}"
}

# ---------------------------------------------------------------------------
# 检测/安装依赖（数据库引擎等）
# ---------------------------------------------------------------------------
# 返回辅助脚本在“执行侧”的路径（本地=仓库，远程=暂存目录）
_scripts_base() {
    if [[ "${MODE}" == "remote" ]]; then echo "${REMOTE_STAGE}/scripts"; else echo "${SCRIPT_DIR}"; fi
}

step_deps() {
    [[ "${DO_DEPS}" == "y" ]] || return 0
    title "检测/安装依赖"
    local base; base="$(_scripts_base)"
    local api_port="${MINIO_ENDPOINT##*:}"
    # 需要的组件：若要装 Casdoor 则一并确保 docker
    local comps="postgres mongo redis minio mc"
    [[ "${DO_CASDOOR}" == "y" ]] && comps="${comps} docker"
    run "MINIO_API_PORT='${api_port}' MINIO_ROOT_USER='${MINIO_ROOT_USER}' MINIO_ROOT_PASSWORD='${MINIO_ROOT_PASSWORD}' bash '${base}/install_deps.sh' ${comps}"
    ok "依赖检测/安装完成"
}

# ---------------------------------------------------------------------------
# 安装 Casdoor
# ---------------------------------------------------------------------------
step_casdoor() {
    [[ "${DO_CASDOOR}" == "y" ]] || return 0
    title "安装 Casdoor"
    local base; base="$(_scripts_base)"
    run "CASDOOR_DIR='${CASDOOR_DIR}' CASDOOR_PORT='${CASDOOR_PORT}' \
         CASDOOR_PG_USER='${CASDOOR_PG_USER}' CASDOOR_PG_PASSWORD='${CASDOOR_PG_PASSWORD}' \
         CASDOOR_DB_NAME='${CASDOOR_DB_NAME}' CASDOOR_ORIGIN='${CASDOOR_ORIGIN}' \
         bash '${base}/install_casdoor.sh'"
    ok "Casdoor 安装步骤结束（后续配置见 DEPLOYMENT.md）"
}

# ---------------------------------------------------------------------------
# 安装/配置 Caddy 反向代理
# ---------------------------------------------------------------------------
step_caddy() {
    [[ "${DO_CADDY}" == "y" ]] || return 0
    title "安装/配置 Caddy 反向代理"
    local base; base="$(_scripts_base)"
    run "CADDY_DOMAIN='${CADDY_DOMAIN}' CADDY_TLS_MODE='${CADDY_TLS_MODE}' \
         CADDY_ACME_EMAIL='${CADDY_ACME_EMAIL}' \
         CADDY_TLS_CERT='${CADDY_TLS_CERT}' CADDY_TLS_KEY='${CADDY_TLS_KEY}' \
         CADDY_FRONTEND_PORT='${CADDY_FRONTEND_PORT}' CADDY_BACKEND_PORT='${CADDY_BACKEND_PORT}' \
         CADDY_INCLUDE_CASDOOR='${CADDY_INCLUDE_CASDOOR}' CADDY_CASDOOR_PORT='${CASDOOR_PORT}' \
         CADDY_INCLUDE_MINIO='${CADDY_INCLUDE_MINIO}' CADDY_MINIO_CONSOLE_PORT='9199' \
         CADDY_SERVE_STATIC='${CADDY_SERVE_STATIC}' CADDY_STATIC_ROOT='${DEPLOY_ROOT}/fwh-toolbox' \
         bash '${base}/install_caddy.sh'"
    ok "Caddy 反向代理配置结束"
}

# ---------------------------------------------------------------------------
# 安装 Kiro CLI（后端 AI 对话依赖）
# ---------------------------------------------------------------------------
step_kiro() {
    [[ "${DO_KIRO}" == "y" ]] || return 0
    title "安装 Kiro CLI"
    local base; base="$(_scripts_base)"
    # 以后端运行用户身份安装；HOME 用 config.env 约定的 /home/<user>（KIRO_HOME 默认取家目录）
    run "KIRO_RUN_AS_USER='${RUN_USER}' KIRO_HOME='/home/${RUN_USER}' \
         KIRO_INSTALL_METHOD='${KIRO_INSTALL_METHOD}' KIRO_LIBC='${KIRO_LIBC}' \
         KIRO_DO_LOGIN='${KIRO_DO_LOGIN}' \
         bash '${base}/install_kiro_cli.sh'"
    ok "Kiro CLI 安装步骤结束"
}

# ---------------------------------------------------------------------------
# 初始化数据库
# ---------------------------------------------------------------------------
step_initdb() {
    [[ "${DO_INITDB}" == "y" ]] || return 0
    title "初始化数据库"
    local sql_path minio_ep
    minio_ep="http://${MINIO_ENDPOINT}"
    if [[ "${MODE}" == "remote" ]]; then
        sql_path="${REMOTE_STAGE}/sql/init_pgsql.sql"
    else
        sql_path="${SQL_FILE}"
    fi

    # 1) PostgreSQL
    info "PostgreSQL 建库/建表 ..."
    run "sudo -u postgres psql -v ON_ERROR_STOP=1 -v fwh_pwd='$(printf '%s' "${PG_PASS}")' -f '${sql_path}'" \
        && ok "PostgreSQL 完成" || { err "PostgreSQL 初始化失败"; return 1; }

    # 2) Mongo / Redis 连通性
    run "command -v mongosh >/dev/null 2>&1 && mongosh --quiet '${MONGO_DSN%%/*}//${MONGO_DSN#*//}' --eval 'db.runCommand({ping:1}).ok' >/dev/null 2>&1 && echo mongo-ok || true"
    run "command -v redis-cli >/dev/null 2>&1 && [ \"\$(redis-cli -h ${REDIS_ADDR%%:*} -p ${REDIS_ADDR##*:} ping 2>/dev/null)\" = PONG ] && echo redis-ok || true"

    # 3) MinIO bucket
    info "MinIO 建桶（若已存在则跳过）..."
    run "if command -v mc >/dev/null 2>&1; then \
            mc alias set fwhlocal '${minio_ep}' '${MINIO_ROOT_USER}' '${MINIO_ROOT_PASSWORD}' >/dev/null 2>&1 || true; \
            mc ls fwhlocal/'${MINIO_BUCKET}' >/dev/null 2>&1 || mc mb fwhlocal/'${MINIO_BUCKET}'; \
            echo minio-ok; \
         else echo 'no-mc(请手动在 MinIO 控制台建桶)'; fi"
    ok "数据库初始化步骤结束"
}

# ---------------------------------------------------------------------------
# 部署后端
# ---------------------------------------------------------------------------
step_backend() {
    [[ "${DO_BACKEND}" == "y" ]] || return 0
    title "部署后端"
    local server_dir="${DEPLOY_ROOT}/server"
    local svc="/etc/systemd/system/${APP_NAME}.service"

    if [[ "${MODE}" == "remote" ]]; then
        run "sudo mkdir -p '${server_dir}' && \
             sudo mv '${REMOTE_STAGE}/${APP_NAME}' '${server_dir}/' && \
             sudo mv '${REMOTE_STAGE}/${MCP_NAME}' '${server_dir}/' && \
             sudo chmod +x '${server_dir}/${APP_NAME}' '${server_dir}/${MCP_NAME}' && \
             { [ -d '${REMOTE_STAGE}/cert' ] && sudo cp -r '${REMOTE_STAGE}/cert' '${server_dir}/' || true; } && \
             { [ -f '${REMOTE_STAGE}/config.env' ] && sudo cp '${REMOTE_STAGE}/config.env' '${server_dir}/config.env' || true; } && \
             { [ -f '${REMOTE_STAGE}/config.mcp.env' ] && sudo cp '${REMOTE_STAGE}/config.mcp.env' '${server_dir}/config.mcp.env' || true; }"
    else
        sudo mkdir -p "${server_dir}"
        sudo mv "${SERVICE_DIR}/${APP_NAME}" "${server_dir}/"
        sudo mv "${SERVICE_DIR}/${MCP_NAME}" "${server_dir}/"
        sudo chmod +x "${server_dir}/${APP_NAME}" "${server_dir}/${MCP_NAME}"
        [[ -d "${SERVICE_DIR}/cert" ]] && sudo cp -r "${SERVICE_DIR}/cert" "${server_dir}/" || true
        [[ -n "${GEN_CONFIG}" ]] && sudo cp "${GEN_CONFIG}" "${server_dir}/config.env" || true
        [[ -n "${GEN_CONFIG}" ]] && sudo cp "${GEN_CONFIG}" "${server_dir}/config.mcp.env" || true
    fi

    # 写入 systemd 服务
    local unit_content
    unit_content="[Unit]
Description=${APP_NAME} service
After=network.target postgresql.service mongod.service redis-server.service minio.service

[Service]
ExecStart=${server_dir}/${APP_NAME}
Restart=always
User=${RUN_USER}
WorkingDirectory=${server_dir}
CPUQuota=200%
MemoryLimit=2G

[Install]
WantedBy=multi-user.target"

    run "echo '$(printf '%s' "${unit_content}" | sed "s/'/'\\\\''/g")' | sudo tee '${svc}' >/dev/null && \
         sudo systemctl daemon-reload && sudo systemctl enable '${APP_NAME}' && \
         ( sudo systemctl restart '${APP_NAME}' || sudo systemctl start '${APP_NAME}' ) && \
         sudo systemctl --no-pager status '${APP_NAME}' | head -n 6"
    ok "后端部署完成"
}

# ---------------------------------------------------------------------------
# 部署前端
# ---------------------------------------------------------------------------
step_frontend() {
    [[ "${DO_FRONTEND}" == "y" ]] || return 0
    title "部署前端"
    local dist_dir="${DEPLOY_ROOT}/fwh-toolbox"
    if [[ "${MODE}" == "remote" ]]; then
        run "sudo mkdir -p '${dist_dir}' && sudo rm -rf '${dist_dir}'/* && \
             sudo tar xzf '${REMOTE_STAGE}/fwh-dist.tgz' -C '${dist_dir}'"
    else
        sudo mkdir -p "${dist_dir}"
        sudo rm -rf "${dist_dir:?}/"*
        sudo cp -rf "${PROJECT_ROOT}/dist/"* "${dist_dir}/"
    fi
    ok "前端部署完成：${dist_dir}"
}

# ---------------------------------------------------------------------------
# 收尾
# ---------------------------------------------------------------------------
cleanup() {
    [[ -n "${GEN_CONFIG}" && -f "${GEN_CONFIG}" ]] && rm -f "${GEN_CONFIG}"
    if [[ "${MODE}" == "remote" ]]; then
        ssh_run "rm -rf ${REMOTE_STAGE}" >/dev/null 2>&1 || true
    fi
}

summary() {
    title "部署完成"
    echo "模式        : ${MODE}"
    [[ "${MODE}" == "remote" ]] && echo "远程主机    : ${R_USER}@${R_HOST}:${R_PORT}"
    echo "部署根目录  : ${DEPLOY_ROOT}"
    echo "已执行步骤  : $( [[ ${DO_DEPS} == y ]] && echo -n '依赖 ' )$( [[ ${DO_CASDOOR} == y ]] && echo -n 'Casdoor ' )$( [[ ${DO_INITDB} == y ]] && echo -n '初始化DB ' )$( [[ ${DO_BACKEND} == y ]] && echo -n '后端 ' )$( [[ ${DO_FRONTEND} == y ]] && echo -n '前端 ' )$( [[ ${DO_CADDY} == y ]] && echo -n 'Caddy ' )$( [[ ${DO_KIRO} == y ]] && echo -n 'KiroCLI ' )"
    echo
    echo "后续："
    if [[ "${DO_CADDY}" == "y" ]]; then
        echo "  * Caddy 已配置：https://${CADDY_DOMAIN}/fwh-toolbox/ （站点文件 /etc/caddy/sites/fwh-toolbox.caddy）"
        [[ "${CADDY_TLS_MODE}" == "internal" ]] && echo "    注意：TLS=internal 为自签证书，浏览器会告警，生产请改用 acme/manual。"
    else
        echo "  * 配置并重载反向代理 Caddy（见 deploy/DEPLOYMENT.md 第 9 章）"
    fi
    if [[ "${DO_CASDOOR}" == "y" ]]; then
        echo "  * 配置 Casdoor：登录 ${CASDOOR_ORIGIN} (admin/123)，创建组织/应用，"
        echo "    取得 clientId/clientSecret/证书，并反代 /casdoor（见 DEPLOYMENT.md《Casdoor 配置》）"
    fi
    if [[ "${DO_KIRO}" == "y" ]]; then
        echo "  * Kiro CLI 已安装（用户 ${RUN_USER}）。"
        if [[ "${KIRO_DO_LOGIN}" != "y" ]]; then
            if [[ "${MODE}" == "remote" ]]; then
                echo "    登录：ssh ${R_USER}@${R_HOST} 'sudo -u ${RUN_USER} -H kiro-cli login'（Builder ID，交互式）"
            else
                echo "    登录：sudo -u ${RUN_USER} -H kiro-cli login（Builder ID，交互式）"
            fi
        fi
        echo "    确认 config.env 的 KIRO_RUN_AS_USER=${RUN_USER}、KIRO_HOME=/home/${RUN_USER} 一致，后端方能拉起 AI 对话。"
    fi
    echo "  * 验证：curl http://127.0.0.1:${APP_PORT}/swagger/index.html"
    if [[ "${MODE}" == "remote" ]]; then
        echo "  * 查看后端日志：ssh ${R_USER}@${R_HOST} 'journalctl -u ${APP_NAME} -f'"
    else
        echo "  * 查看后端日志：journalctl -u ${APP_NAME} -f"
    fi
}

usage() {
    cat <<EOF
FranklinWH Toolbox 交互式一键部署

用法：
  $0            进入交互式向导（选择 local/remote，分步选择与填写）
  $0 --help     显示本帮助

向导步骤：
  0. 选择模式（本地/远程）与要执行的步骤
  1. （远程）填写 SSH 连接信息并测试
  2. 填写部署目录、运行用户与各项配置
  3. 生成 config.env
  4. 本地构建前端 dist 与后端二进制
  5. （远程）打包上传产物与辅助脚本
  6. 检测/安装依赖 → 安装 Casdoor → 初始化数据库 → 部署后端 → 部署前端 → 配置 Caddy → 安装 Kiro CLI

可选步骤（向导中勾选）：
  * 检测/安装数据库引擎与依赖（PostgreSQL/MongoDB/Redis/MinIO/Docker）
  * 安装 Casdoor（Docker，认证服务）
  * 安装并配置 Caddy 反向代理（生成站点 Caddyfile 并 reload）
  * 安装 Kiro CLI（后端 AI 对话依赖，以运行用户安装并登录 Builder ID）
EOF
}

main() {
    if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then usage; exit 0; fi

    trap cleanup EXIT

    wizard_intro
    wizard_remote
    wizard_params

    title "确认"
    echo "模式=${MODE} 目录=${DEPLOY_ROOT} 运行用户=${RUN_USER}"
    echo "步骤：deps=${DO_DEPS} casdoor=${DO_CASDOOR} initdb=${DO_INITDB} backend=${DO_BACKEND} frontend=${DO_FRONTEND} genconf=${DO_GENCONF} caddy=${DO_CADDY} kiro=${DO_KIRO}"
    ask_yn "确认开始执行？" "y" || { warn "已取消"; exit 0; }

    generate_config
    build_frontend
    build_backend
    prepare_remote_stage
    step_deps
    step_casdoor
    step_initdb
    step_backend
    step_frontend
    step_caddy
    step_kiro
    summary
}

main "$@"