FranklinWH-Toolbox/deploy/scripts/sync_kiro_config.sh

#!/usr/bin/env bash
# =============================================================================
# FranklinWH Toolbox - Kiro CLI 配置单向同步脚本（A → B）
# =============================================================================
# 作用：把「版本库配置源」单向推送到「线上部署目标」。
#
#   A 端（版本库源）：deploy/kiro/
#   B 端（部署目标）：${KIRO_HOME}/.kiro   默认 /var/www/fwh-toolbox/server/.kiro
#
# 同步内容（一律 A → B，不回写）：
#   * steering/            覆盖同步（rsync --delete，B 端该目录与 A 端一致）
#   * agents/              覆盖同步（rsync --delete）
#   * 自定义 skill          扫描 A 端 skills/ 下的目录，逐个覆盖同步到 B 端
#                          （每个 skill 目录内部 --delete，不影响 B 端其它 skill）
#   * skills.sh 生态 skill  读取 skills-sh.list，在 B 端用 `npx skills add` 安装
#                          （要装新的：先在 skills-sh.list 加一行，再跑本脚本）
#
# 不同步：settings/（kiro-cli 自动生成）。
# 安全：顶层 skills/ 不做 --delete，命令安装的 skill 目录不会被误删。
#      另：禁止把配置同步到用户级 ~/.kiro（B 端不能落在任何真实用户 HOME 下），
#      命中即报错退出；确需解除请设 KIRO_ALLOW_USER_HOME=y。
#
# 用法：
#   ./sync_kiro_config.sh                    # 执行同步
#   KIRO_HOME=/path ./sync_kiro_config.sh    # 指定 B 端 HOME
#   KIRO_DRY_RUN=y ./sync_kiro_config.sh     # 预演，只打印动作不落盘
#   KIRO_SKILLS_INSTALL=n ./sync_kiro_config.sh  # 跳过 skills.sh 命令安装，只同步文件
#
# 环境变量：
#   KIRO_HOME            B 端 HOME（决定 .kiro 位置）   (默认 /var/www/fwh-toolbox/server)
#   KIRO_RUN_AS_USER     B 端属主 / 运行 kiro-cli 的用户 (默认当前用户)
#   A_DIR                A 端目录                       (默认 <repo>/deploy/kiro)
#   KIRO_SKILLS_LIST     skills.sh 安装清单文件         (默认 ${A_DIR}/skills-sh.list)
#   KIRO_AGENT           skills CLI 目标 agent          (默认 kiro-cli)
#   KIRO_SKILLS_INSTALL  是否命令安装 skills.sh skill    (默认 y)
#   KIRO_DRY_RUN         只打印不落盘 (y/n)             (默认 n)
#   KIRO_ALLOW_USER_HOME 解除「禁止同步到用户级 ~/.kiro」保护 (y/n) (默认 n)
# =============================================================================
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DEPLOY_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"           # deploy/

KIRO_HOME="${KIRO_HOME:-/var/www/fwh-toolbox/server}"
KIRO_RUN_AS_USER="${KIRO_RUN_AS_USER:-$(id -un)}"
A_DIR="${A_DIR:-${DEPLOY_DIR}/kiro}"
B_DIR="${KIRO_HOME%/}/.kiro"
KIRO_SKILLS_LIST="${KIRO_SKILLS_LIST:-${A_DIR}/skills-sh.list}"
KIRO_AGENT="${KIRO_AGENT:-kiro-cli}"
KIRO_SKILLS_INSTALL="${KIRO_SKILLS_INSTALL:-y}"
KIRO_DRY_RUN="${KIRO_DRY_RUN:-n}"

# 占位符替换目标值（须与 deploy_kiro_cli.sh 保持一致）：
#   __KIRO_HOME__     → ${KIRO_HOME}         （fwh-pyrun、templates 的父路径）
#   __WIKI_DOCS__     → ${KIRO_WIKI_DOCS}     （产品文档知识库目录）
#   __OFFICECLI_BIN__ → ${KIRO_OFFICECLI_BIN} （officecli 可执行文件）
KIRO_WIKI_DOCS="${KIRO_WIKI_DOCS:-/home/jerry-remote/web/FranklinWH-Wiki/client/docs}"
KIRO_OFFICECLI_BIN="${KIRO_OFFICECLI_BIN:-/home/jerry-remote/.local/bin/officecli}"

# A→B 覆盖同步的配置子目录
SYNC_SUBDIRS=(steering agents)

c_reset='\033[0m'; c_blue='\033[1;34m'; c_green='\033[1;32m'; c_yellow='\033[1;33m'; c_red='\033[1;31m'
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; }

has() { command -v "$1" >/dev/null 2>&1; }
is_dry() { [[ "${KIRO_DRY_RUN}" == "y" ]]; }

# 执行文件系统命令（dry-run 只打印）
run_fs() {
    if is_dry; then echo -e "${c_yellow}[DRY]${c_reset} $*"; return 0; fi
    bash -lc "$*"
}

# 以 B 端运行用户身份执行（HOME=KIRO_HOME），用于 npx skills add
as_target_user() {
    local cmd="$*"
    if is_dry; then
        echo -e "${c_yellow}[DRY]${c_reset} (as ${KIRO_RUN_AS_USER}, HOME=${KIRO_HOME}) ${cmd}"
        return 0
    fi
    if [[ "${KIRO_RUN_AS_USER}" == "$(id -un)" ]]; then
        HOME="${KIRO_HOME}" bash -lc "${cmd}"
    else
        sudo -u "${KIRO_RUN_AS_USER}" -H env HOME="${KIRO_HOME}" bash -lc "${cmd}"
    fi
}

# 扫描 A 端 skills/ 下实际存在的自定义 skill 目录名
custom_skill_names() {
    local d
    [[ -d "${A_DIR}/skills" ]] || return 0
    for d in "${A_DIR}/skills"/*/; do
        [[ -d "${d}" ]] && basename "${d}"
    done
}

# 读取 skills.sh 清单：去注释/空行，输出每行 "<owner>/<repo>@<skill>"
read_skills_list() {
    [[ -f "${KIRO_SKILLS_LIST}" ]] || return 0
    sed -E 's/#.*$//; s/[[:space:]]+$//; s/^[[:space:]]+//' "${KIRO_SKILLS_LIST}" \
        | grep -vE '^[[:space:]]*$'
}

# rsync A→B，一个子路径（带 --delete，作用范围仅该子目录）
rsync_dir() {
    local rel="$1"                       # 如 steering、skills/fwh-toolbox-rules
    local src="${A_DIR}/${rel}"
    local dst="${B_DIR}/${rel}"
    [[ -d "${src}" ]] || { warn "跳过（源不存在）：${src}"; return 0; }
    run_fs "sudo mkdir -p '${dst}'"
    if has rsync; then
        run_fs "sudo rsync -a --delete '${src}/' '${dst}/'"
    else
        run_fs "sudo rm -rf '${dst}'/* && sudo cp -rf '${src}/.' '${dst}/'"
    fi
}

# ---------------------------------------------------------------------------
# 1. 同步 steering / agents（覆盖）
# ---------------------------------------------------------------------------
sync_config_dirs() {
    local sub
    for sub in "${SYNC_SUBDIRS[@]}"; do
        info "同步 ${sub}/  (A→B 覆盖)"
        rsync_dir "${sub}"
    done
}

# ---------------------------------------------------------------------------
# 2. 同步自定义 skill（逐个目录覆盖，扫描 A 端）
# ---------------------------------------------------------------------------
sync_custom_skills() {
    local name count=0
    while IFS= read -r name; do
        [[ -z "${name}" ]] && continue
        info "同步自定义 skill：skills/${name}/  (A→B 覆盖)"
        rsync_dir "skills/${name}"
        count=$((count+1))
    done < <(custom_skill_names)
    [[ ${count} -eq 0 ]] && info "A 端无自定义 skill" || ok "自定义 skill 同步完成（共 ${count} 个）"
}

# ---------------------------------------------------------------------------
# 3. 命令安装 skills.sh 生态 skill（读清单，在 B 端安装）
# ---------------------------------------------------------------------------
install_skills_sh() {
    if [[ "${KIRO_SKILLS_INSTALL}" != "y" ]]; then
        info "跳过 skills.sh 命令安装（KIRO_SKILLS_INSTALL=${KIRO_SKILLS_INSTALL}）"
        return 0
    fi
    if [[ ! -f "${KIRO_SKILLS_LIST}" ]]; then
        warn "未找到清单文件：${KIRO_SKILLS_LIST}，跳过命令安装"
        return 0
    fi
    if ! has npx; then
        warn "无 npx，跳过 skills.sh 命令安装"
        return 0
    fi
    info "从清单安装 skills.sh skill：${KIRO_SKILLS_LIST}"
    local entry repo skill count=0
    while IFS= read -r entry; do
        [[ -z "${entry}" ]] && continue
        if [[ "${entry}" != *"@"* ]]; then
            warn "清单行格式不符（应为 owner/repo@skill），跳过：${entry}"
            continue
        fi
        repo="${entry%@*}"
        skill="${entry##*@}"
        info "安装 skill：${repo} --skill ${skill} → agent ${KIRO_AGENT}"
        as_target_user "cd '${KIRO_HOME}' && npx --yes skills add '${repo}' --skill '${skill}' --agent '${KIRO_AGENT}' --yes" \
            || warn "skill 安装失败（可稍后重试）：${entry}"
        count=$((count+1))
    done < <(read_skills_list)
    ok "skills.sh skill 命令安装完成（共 ${count} 个）"
}

# ---------------------------------------------------------------------------
# 4. 替换占位符（与 deploy_kiro_cli.sh 一致）
#    A 端源文件存的是带占位符的模板，rsync 到 B 端后必须替换为真实路径，
#    否则 agents/*.json 的命令白名单、officecli 路径、skills 文档会残留 __XXX__。
#    作用范围：B 端 agents/*.json 与 skills/**/*.md。
# ---------------------------------------------------------------------------
replace_placeholders() {
    info "替换占位符：__KIRO_HOME__=${KIRO_HOME%/}  __WIKI_DOCS__=${KIRO_WIKI_DOCS%/}  __OFFICECLI_BIN__=${KIRO_OFFICECLI_BIN}"
    # 用 # 作为 sed 分隔符（路径含 /）；替换值不含 #
    local sed_expr="s#__KIRO_HOME__#${KIRO_HOME%/}#g; s#__WIKI_DOCS__#${KIRO_WIKI_DOCS%/}#g; s#__OFFICECLI_BIN__#${KIRO_OFFICECLI_BIN}#g"
    if [[ -d "${B_DIR}/agents" ]]; then
        run_fs "sudo find '${B_DIR}/agents' -maxdepth 1 -type f -name '*.json' -exec sed -i -E '${sed_expr}' {} +"
    fi
    if [[ -d "${B_DIR}/skills" ]]; then
        run_fs "sudo find '${B_DIR}/skills' -type f -name '*.md' -exec sed -i -E '${sed_expr}' {} +"
    fi
    ok "占位符替换完成"
}

# ---------------------------------------------------------------------------
# 安全守卫：禁止把配置同步到「用户级目录」
#   本脚本是 A→B 的部署同步，B 端应为服务账户的部署目录（如
#   /var/www/fwh-toolbox/server/.kiro），绝不能指向某个真实用户的 HOME
#   下的 ~/.kiro，否则 rsync --delete 会覆盖/删除用户自己的 steering、
#   agents、skills（曾因此丢失用户级配置）。
#
#   判定规则（任一命中即拒绝）：
#     * B_DIR 解析后正好等于 “<某 HOME>/.kiro”，或位于其下；
#     * 该 HOME 来源：当前执行用户 $HOME、KIRO_RUN_AS_USER 的 HOME、
#       以及常见用户家目录前缀 /home/*、/Users/*、/root。
#   用物理路径比较，避免 ..、软链接、结尾斜杠绕过。可用
#   KIRO_ALLOW_USER_HOME=y 显式解除（仅限明确知道后果时）。
# ---------------------------------------------------------------------------
abspath() {
    # 输出物理绝对路径；路径可能尚不存在，故对父目录逐级回退解析
    local p="$1"
    if command -v realpath >/dev/null 2>&1; then
        realpath -m -- "${p}" 2>/dev/null && return 0
    fi
    if command -v readlink >/dev/null 2>&1; then
        readlink -f -- "${p}" 2>/dev/null && return 0
    fi
    # 兜底：去掉结尾斜杠，原样返回
    echo "${p%/}"
}

guard_not_user_home() {
    if [[ "${KIRO_ALLOW_USER_HOME:-n}" == "y" ]]; then
        warn "已设置 KIRO_ALLOW_USER_HOME=y，跳过用户级目录保护（请自行确认后果）"
        return 0
    fi

    local b_abs; b_abs="$(abspath "${B_DIR}")"

    # 收集需要保护的 HOME 列表
    local -a homes=()
    [[ -n "${HOME:-}" ]] && homes+=("${HOME}")
    local run_home
    run_home="$(getent passwd "${KIRO_RUN_AS_USER}" 2>/dev/null | cut -d: -f6)"
    [[ -n "${run_home}" ]] && homes+=("${run_home}")

    local h h_abs
    for h in "${homes[@]}"; do
        [[ -z "${h}" || "${h}" == "/" ]] && continue
        h_abs="$(abspath "${h}")"
        # B_DIR 恰为 <HOME>/.kiro，或位于 <HOME>/ 之下
        if [[ "${b_abs}" == "${h_abs}/.kiro" || "${b_abs}" == "${h_abs}/.kiro/"* ]]; then
            err "拒绝同步：B 端目标 ${b_abs} 位于用户 HOME（${h_abs}）下，属于用户级 .kiro 目录。"
            err "本脚本只允许同步到服务部署目录。若确需覆盖用户级目录，请设 KIRO_ALLOW_USER_HOME=y。"
            exit 1
        fi
    done

    # 额外拦截：B_DIR 直接落在常见「用户家目录」前缀下（覆盖非当前用户的情况）
    case "${b_abs}" in
        /home/*/.kiro|/home/*/.kiro/*|/Users/*/.kiro|/Users/*/.kiro/*|/root/.kiro|/root/.kiro/*)
            err "拒绝同步：B 端目标 ${b_abs} 看起来是用户级 .kiro 目录（位于 /home、/Users 或 /root 下）。"
            err "本脚本只允许同步到服务部署目录。若确需覆盖用户级目录，请设 KIRO_ALLOW_USER_HOME=y。"
            exit 1
            ;;
    esac

    ok "用户级目录保护检查通过：B 端 ${b_abs} 非用户级 .kiro"
}

# ---------------------------------------------------------------------------
# main
# ---------------------------------------------------------------------------
main() {
    info "== Kiro 配置单向同步（A → B）=="
    info "A 端（版本库）  ：${A_DIR}"
    info "B 端（部署目标）：${B_DIR}"
    info "自定义 skill    ：$(custom_skill_names | tr '\n' ' ')"
    info "skills.sh 清单  ：${KIRO_SKILLS_LIST}（命令安装=${KIRO_SKILLS_INSTALL}）"
    info "dry-run=${KIRO_DRY_RUN}"

    if [[ ! -d "${A_DIR}" ]]; then err "A 端不存在：${A_DIR}"; exit 1; fi

    # 写操作前的安全守卫：禁止同步到用户级 ~/.kiro
    guard_not_user_home

    sync_config_dirs
    sync_custom_skills
    install_skills_sh
    replace_placeholders

    # 属主归还给 B 端运行用户
    run_fs "sudo chown -R '${KIRO_RUN_AS_USER}' '${B_DIR}'"

    ok "同步结束"
}

main "$@"