chore:部署脚本去掉Kiro CLI安装与旧MCP构建，MinIO不再创建fwh-toolbox-ai-file桶

- 删除deploy/kiro与install/deploy/sync_kiro脚本、config.mcp.env.example
- setup.sh、deploy.sh、start.sh去掉kiro步骤和fwh-mcp-server；保留fwh-toolbox-ai账号（新助手只读使用）

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

deploy/config.agent-mcp.env.example

@@ -3,7 +3,7 @@
 # 使用方式：复制到部署目录 /var/www/fwh-toolbox/server/config.agent-mcp.env 后按需修改，
 #           切勿把真实密钥提交到仓库。
 # 读取路径：只读取工作目录下的 ./config.agent-mcp.env（-config 可指定），
-#           与主服务的 config.env、旧 MCP 的 config.mcp.env 互不共用；环境变量可覆盖文件内配置。
+#           与主服务的 config.env 互不共用；环境变量可覆盖文件内配置。
 #           文件不存在时服务拒绝启动。
 #
 # 说明：只包含 fwh-agent-mcp 用到的配置子集（数据库 / 缓存、MinIO 只读、FWH 生产与测试 API、FWH ES、Plane Web）。
@@ -35,7 +35,7 @@ REDIS_ADDR="localhost:6379"
 
 # ---------- MinIO（只读）----------
 # 故障录波文件（fault-record/ 前缀）的读取：fault_record_data、fault_record_export。
-# 使用 AI 专用账号 fwh-toolbox-ai（对 fwh-toolbox 桶只读，由 provision_minio.sh 创建），与旧 MCP 的 config.mcp.env 相同
+# 使用 AI 专用账号 fwh-toolbox-ai（对 fwh-toolbox 桶只读，由 provision_minio.sh 创建）
 MINIO_ENDPOINT="localhost:9198"
 MINIO_ACCESS_KEY="fwh-toolbox-ai"
 MINIO_SECRET_KEY="CHANGE_ME"

deploy/config.env.example

@@ -98,11 +98,6 @@ PLANE_WEB_LABEL_BUG="CHANGE_ME"
 PLANE_WEB_LABEL_FEATURE="CHANGE_ME"
 PLANE_WEB_LABEL_FEEDBACK="CHANGE_ME"
 
-# ---------- Kiro（AI Chat 子进程降权，可选）----------
-# TODO: [确认] 拉起 kiro-cli 子进程时降权到的系统用户及其 HOME（改成目标机的实际用户）
-KIRO_RUN_AS_USER=jerry-remote
-KIRO_HOME=/home/jerry-remote
-
 # ---------- 新 AI 助手（AgentServer，可选）----------
 # 见 docs/ai-assistant-agentserver/technical-design.md §3.2；未开启时 AI 助手页面显示暂未开放、/agent/* 接口返回 403
 # AGENT_ENABLED=true

deploy/scripts/deploy.sh

@@ -4,19 +4,17 @@
 # =============================================================================
 # 作用：
 #   1. 构建前端（pnpm build）并同步到静态目录
-#   2. 构建后端主程序 fwh-toolbox-server 与 fwh-mcp-server，安装 systemd 服务
-#   3. 部署 Kiro CLI 配置（agents/settings/steering/skills）到 server/.kiro
+#   2. 构建后端主程序 fwh-toolbox-server，安装 systemd 服务
 #
 # 目录约定（与线上服务器保持一致，可用环境变量覆盖）：
 #   DEPLOY_ROOT   /var/www/fwh-toolbox
 #     ├── fwh-toolbox/   前端静态文件（构建产物 dist/*）
-#     └── server/        后端二进制 + config.env + config.mcp.env + cert/ + .kiro/（kiro-cli 配置）
+#     └── server/        后端二进制 + config.env + cert/
 #
 # 用法：
-#   ./deploy.sh all        # 前端 + 后端 + Kiro 配置（默认）
+#   ./deploy.sh all        # 前端 + 后端（默认）
 #   ./deploy.sh frontend   # 仅前端
 #   ./deploy.sh backend    # 仅后端
-#   ./deploy.sh kiro       # 仅 Kiro CLI 配置（含 skills 安装/拷贝）
 #
 # 前置条件：
 #   - 已安装 Go、Node、pnpm（见 docs/DEPLOYMENT.md）
@@ -29,21 +27,15 @@ DEPLOY_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"           # deploy/
 PROJECT_ROOT="$(cd "${DEPLOY_DIR}/.." && pwd)"         # 仓库根目录
 SERVICE_DIR="${PROJECT_ROOT}/service"                  # Go 后端目录
 CONFIG_EXAMPLE="${DEPLOY_DIR}/config.env.example"      # 后端配置模板
-MCP_CONFIG_EXAMPLE="${DEPLOY_DIR}/config.mcp.env.example"  # MCP 配置模板
 
 DEPLOY_ROOT="${DEPLOY_ROOT:-/var/www/fwh-toolbox}"
 FRONTEND_DIST_DIR="${DEPLOY_ROOT}/fwh-toolbox"
 SERVER_DIR="${DEPLOY_ROOT}/server"
 
 APP_NAME="fwh-toolbox-server"
-MCP_NAME="fwh-mcp-server"
 SERVICE_FILE="/etc/systemd/system/${APP_NAME}.service"
 RUN_USER="${RUN_USER:-jerry-remote}"
 
-# Kiro CLI 配置部署（AI 对话依赖）：目标用户与 HOME 需与后端拉起 kiro-cli 时一致
-KIRO_RUN_AS_USER="${KIRO_RUN_AS_USER:-${RUN_USER}}"
-KIRO_HOME="${KIRO_HOME:-${SERVER_DIR}}"
-
 info() { echo -e "\033[1;34m[INFO]\033[0m $*"; }
 ok()   { echo -e "\033[1;32m[ OK ]\033[0m $*"; }
 
@@ -69,7 +61,6 @@ build_backend() {
     info "构建后端二进制 ..."
     cd "${SERVICE_DIR}"
     GOOS=linux GOARCH=amd64 go build -o "${APP_NAME}" ./
-    GOOS=linux GOARCH=amd64 go build -o "${MCP_NAME}" ./cmd/mcp/
     ok "后端构建完成"
 }
 
@@ -103,19 +94,13 @@ deploy_backend() {
     sudo mkdir -p "${SERVER_DIR}"
     info "安装二进制到 ${SERVER_DIR} ..."
     sudo mv "${SERVICE_DIR}/${APP_NAME}" "${SERVER_DIR}/${APP_NAME}"
-    sudo mv "${SERVICE_DIR}/${MCP_NAME}" "${SERVER_DIR}/${MCP_NAME}"
-    sudo chmod +x "${SERVER_DIR}/${APP_NAME}" "${SERVER_DIR}/${MCP_NAME}"
+    sudo chmod +x "${SERVER_DIR}/${APP_NAME}"
 
     if [[ ! -f "${SERVER_DIR}/config.env" ]]; then
         info "未发现 ${SERVER_DIR}/config.env，从示例模板复制（请务必修改其中的密钥）"
         sudo cp "${CONFIG_EXAMPLE}" "${SERVER_DIR}/config.env"
     fi
 
-    if [[ ! -f "${SERVER_DIR}/config.mcp.env" ]]; then
-        info "未发现 ${SERVER_DIR}/config.mcp.env，从示例模板复制（MCP 独立配置，请务必修改其中的密钥）"
-        sudo cp "${MCP_CONFIG_EXAMPLE}" "${SERVER_DIR}/config.mcp.env"
-    fi
-
     install_service
 
     if systemctl is-active --quiet "${APP_NAME}"; then
@@ -129,24 +114,13 @@ deploy_backend() {
     ok "后端部署完成"
 }
 
-# ---------------------------------------------------------------------------
-# Kiro CLI 配置（agents / settings / steering / skills）
-# ---------------------------------------------------------------------------
-deploy_kiro() {
-    info "部署 Kiro CLI 配置到 ${KIRO_HOME}/.kiro ..."
-    KIRO_RUN_AS_USER="${KIRO_RUN_AS_USER}" KIRO_HOME="${KIRO_HOME}" \
-        bash "${SCRIPT_DIR}/deploy_kiro_cli.sh"
-    ok "Kiro CLI 配置部署完成"
-}
-
 main() {
     local target="${1:-all}"
     case "${target}" in
         frontend) deploy_frontend ;;
         backend)  deploy_backend ;;
-        kiro)     deploy_kiro ;;
-        all)      deploy_frontend; deploy_backend; deploy_kiro ;;
-        *) echo "用法: $0 [all|frontend|backend|kiro]"; exit 1 ;;
+        all)      deploy_frontend; deploy_backend ;;
+        *) echo "用法: $0 [all|frontend|backend]"; exit 1 ;;
     esac
     echo "===== 部署结束 ====="
 }

deploy/scripts/provision_minio.sh

@@ -3,20 +3,18 @@
 # FranklinWH Toolbox - MinIO 业务账号与策略配置脚本
 # =============================================================================
 # 作用（使用 root 管理员账户，通过 mc admin 完成）：
-#   1. 创建业务 bucket：fwh-toolbox、fwh-toolbox-ai-file
+#   1. 创建业务 bucket：fwh-toolbox
 #   2. 创建两条自定义策略（基于桶名前缀通配）：
 #        - fwh-toolbox-rw    ：对 fwh-toolbox*      前缀桶可读写(含删)，其余桶只读
 #        - fwh-toolbox-ai-rw ：对 fwh-toolbox-ai*   前缀桶可读写(含删)，其余桶只读
 #   3. 创建两个业务用户并绑定对应策略：
 #        - fwh-toolbox     （后端主业务，用 MINIO_ACCESS_KEY/MINIO_SECRET_KEY）
-#        - fwh-toolbox-ai  （AI 文件，用 MINIO_AI_ACCESS_KEY/MINIO_AI_SECRET_KEY）
+#        - fwh-toolbox-ai  （AI 助手 fwh-agent-mcp 只读访问，用 MINIO_AI_ACCESS_KEY/MINIO_AI_SECRET_KEY）
 #
 # 账号职责：
 #   root 管理员   -> 建桶/建用户/设策略（全局管理）
 #   fwh-toolbox   -> 写 fwh-toolbox* 桶，读其余所有桶
-#   fwh-toolbox-ai-> 写 fwh-toolbox-ai* 桶，读其余所有桶
-#   注意：fwh-toolbox-ai-file 同时匹配 fwh-toolbox* 与 fwh-toolbox-ai*，
-#         因此两个用户对该桶均有写权限（前缀通配的必然结果）。
+#   fwh-toolbox-ai-> 写 fwh-toolbox-ai* 桶（目前没有此类桶），读其余所有桶
 #
 # 前置条件：
 #   - MinIO 已运行；mc（MinIO Client）已安装（见 install_deps.sh）
@@ -37,7 +35,6 @@
 #   MINIO_AI_ACCESS_KEY  AI 用户 AK                            (默认 fwh-toolbox-ai)
 #   MINIO_AI_SECRET_KEY  AI 用户 SK                            (默认 fwh-toolbox-ai)
 #   MINIO_BUCKET         主业务 bucket 名                       (默认 fwh-toolbox)
-#   MINIO_AI_BUCKET      AI 文件 bucket 名                      (默认 fwh-toolbox-ai-file)
 # =============================================================================
 set -euo pipefail
 
@@ -54,7 +51,6 @@ MINIO_SECRET_KEY="${MINIO_SECRET_KEY:-fwh-toolbox}"
 MINIO_AI_ACCESS_KEY="${MINIO_AI_ACCESS_KEY:-fwh-toolbox-ai}"
 MINIO_AI_SECRET_KEY="${MINIO_AI_SECRET_KEY:-fwh-toolbox-ai}"
 MINIO_BUCKET="${MINIO_BUCKET:-fwh-toolbox}"
-MINIO_AI_BUCKET="${MINIO_AI_BUCKET:-fwh-toolbox-ai-file}"
 
 # 策略名与前缀（如需改动桶前缀在此调整）
 POLICY_BIZ="fwh-toolbox-rw"
@@ -103,7 +99,7 @@ set_alias() {
 # ---------------------------------------------------------------------------
 ensure_buckets() {
     local b
-    for b in "${MINIO_BUCKET}" "${MINIO_AI_BUCKET}"; do
+    for b in "${MINIO_BUCKET}"; do
         if mc ls "${MINIO_ALIAS}/${b}" >/dev/null 2>&1; then
             ok "bucket 已存在：${b}"
         else
@@ -203,15 +199,13 @@ main() {
 
 ${c_green}MinIO 配置完成${c_reset}
   Endpoint : ${MINIO_ENDPOINT}
-  Buckets  : ${MINIO_BUCKET}, ${MINIO_AI_BUCKET}
+  Buckets  : ${MINIO_BUCKET}
 
   账号与权限：
     root(${MINIO_ROOT_USER})           -> 全局管理
     ${MINIO_ACCESS_KEY}                 -> 策略 ${POLICY_BIZ}：写 ${PREFIX_BIZ}* 桶(含删)，读其余所有桶
     ${MINIO_AI_ACCESS_KEY}              -> 策略 ${POLICY_AI}：写 ${PREFIX_AI}* 桶(含删)，读其余所有桶
 
-  ${c_yellow}提示${c_reset}：${MINIO_AI_BUCKET} 同时匹配 ${PREFIX_BIZ}* 与 ${PREFIX_AI}*，
-        故 ${MINIO_ACCESS_KEY} 与 ${MINIO_AI_ACCESS_KEY} 对该桶均可写。
   请确保 config.env 中 MINIO_ACCESS_KEY/MINIO_SECRET_KEY 与此处业务用户一致。
 EOF
 }

deploy/scripts/setup.sh

@@ -31,10 +31,8 @@ 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"
-MCP_CONFIG_EXAMPLE="${DEPLOY_DIR}/config.mcp.env.example"
 
 APP_NAME="fwh-toolbox-server"
-MCP_NAME="fwh-mcp-server"
 
 # ---------------------------------------------------------------------------
 # 输出辅助
@@ -240,7 +238,7 @@ require_cmd() {
 # 全局变量（向导填写）
 # ---------------------------------------------------------------------------
 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"; DO_PGADMIN="n"; DO_MINIOACCT="y"
+DO_DEPS="y"; DO_CASDOOR="n"; DO_INITDB="y"; DO_BACKEND="y"; DO_FRONTEND="y"; DO_GENCONF="y"; DO_CADDY="n"; DO_PGADMIN="n"; DO_MINIOACCT="y"
 
 # 远程连接
 R_HOST=""; R_PORT="22"; R_USER=""; R_SSH_KEY=""
@@ -259,7 +257,7 @@ 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="fwh-toolbox"; MINIO_SECRET_KEY="fwh-toolbox"; MINIO_BUCKET="fwh-toolbox"  # TODO: [确认] MinIO 业务 AK/SK（默认 fwh-toolbox）
-MINIO_AI_ACCESS_KEY="fwh-toolbox-ai"; MINIO_AI_SECRET_KEY="fwh-toolbox-ai"; MINIO_AI_BUCKET="fwh-toolbox-ai-file"  # MCP 用 AI 账号（provision_minio.sh 创建）
+MINIO_AI_ACCESS_KEY="fwh-toolbox-ai"; MINIO_AI_SECRET_KEY="fwh-toolbox-ai"  # AI 助手 fwh-agent-mcp 用的只读账号（provision_minio.sh 创建）
 MINIO_ROOT_USER="jerry"; MINIO_ROOT_PASSWORD=""  # TODO: [必填] MinIO 管理员密码向导内强制输入
 
 # pgAdmin4（数据库 Web 管理，可选）
@@ -279,14 +277,8 @@ 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=""
-GEN_MCP_CONFIG=""
 
 # 单项模式（--only）：非空表示仅执行指定步骤，跳过步骤勾选交互
 ONLY_MODE=""
@@ -327,9 +319,8 @@ wizard_intro() {
         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"
-    ask_yn "⑨ 部署 pgAdmin4（Docker，数据库 Web 管理，并给 postgres 设密码）？" "n" && DO_PGADMIN="y" || DO_PGADMIN="n"
-    ask_yn "⑩ 创建 MinIO 业务账号与策略（fwh-toolbox / fwh-toolbox-ai）？" "y" && DO_MINIOACCT="y" || DO_MINIOACCT="n"
+    ask_yn "⑧ 部署 pgAdmin4（Docker，数据库 Web 管理，并给 postgres 设密码）？" "n" && DO_PGADMIN="y" || DO_PGADMIN="n"
+    ask_yn "⑨ 创建 MinIO 业务账号与策略（fwh-toolbox / fwh-toolbox-ai）？" "y" && DO_MINIOACCT="y" || DO_MINIOACCT="n"
 }
 
 # ---------------------------------------------------------------------------
@@ -447,12 +438,11 @@ wizard_params() {
     fi
 
     if [[ "${DO_MINIOACCT}" == "y" ]]; then
-        edit_module "MinIO 业务账号（后端 fwh-toolbox / MCP fwh-toolbox-ai）" \
+        edit_module "MinIO 业务账号（后端 fwh-toolbox / AI 助手 fwh-toolbox-ai）" \
             "MINIO_ACCESS_KEY|后端业务 Access Key|plain|fwh-toolbox" \
             "MINIO_SECRET_KEY|后端业务 Secret Key|secret|fwh-toolbox" \
-            "MINIO_AI_ACCESS_KEY|AI Access Key（MCP 用）|plain|fwh-toolbox-ai" \
-            "MINIO_AI_SECRET_KEY|AI Secret Key（MCP 用）|secret|fwh-toolbox-ai" \
-            "MINIO_AI_BUCKET|AI 文件 bucket 名|plain|fwh-toolbox-ai-file"
+            "MINIO_AI_ACCESS_KEY|AI Access Key（fwh-agent-mcp 用）|plain|fwh-toolbox-ai" \
+            "MINIO_AI_SECRET_KEY|AI Secret Key（fwh-agent-mcp 用）|secret|fwh-toolbox-ai"
     fi
 
     if [[ "${DO_CADDY}" == "y" ]]; then
@@ -471,22 +461,6 @@ wizard_params() {
         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_choice _km "输入序号" "1" "1 2"
-        case "${_km}" in
-            1) KIRO_INSTALL_METHOD="zip"
-               echo "C 库变体：1) gnu(默认，主流发行版)  2) musl(Alpine 等)"
-               local _kl; ask_choice _kl "输入序号" "1" "1 2"
-               [[ "${_kl}" == "2" ]] && KIRO_LIBC="musl" || KIRO_LIBC="gnu" ;;
-            2) KIRO_INSTALL_METHOD="curl" ;;
-        esac
-        ask_yn "安装后立即以 ${RUN_USER} 身份登录 Builder ID（交互式，需浏览器）？" "n" \
-            && KIRO_DO_LOGIN="y" || KIRO_DO_LOGIN="n"
-    fi
 }
 
 # ---------------------------------------------------------------------------
@@ -507,7 +481,6 @@ generate_config() {
         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]
@@ -522,7 +495,6 @@ repl = {
     "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:
@@ -533,13 +505,7 @@ 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}"')
+        out.append(f'{m.group(2)}="{repl[m.group(2)]}"')
     else:
         out.append(line)
 open(path, "w", encoding="utf-8").write("\n".join(out) + "\n")
@@ -559,73 +525,8 @@ PY
         _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}"
-
-    # -----------------------------------------------------------------------
-    # 单独生成 config.mcp.env（基于 config.mcp.env.example）
-    #   与后端共享库/缓存/MinIO endpoint/MySQL 等，但 MinIO 使用 AI 专用账号
-    #   fwh-toolbox-ai（对 fwh-toolbox-ai* 桶可读写、其余桶只读；MCP 工具仅只读）。
-    # -----------------------------------------------------------------------
-    if [[ -f "${MCP_CONFIG_EXAMPLE}" ]]; then
-        GEN_MCP_CONFIG="$(mktemp /tmp/fwh_config.mcp.env.XXXXXX)"
-        cp "${MCP_CONFIG_EXAMPLE}" "${GEN_MCP_CONFIG}"
-
-        # MCP 侧 MinIO 使用 AI 账号；默认账号=密码=fwh-toolbox-ai（可用环境变量覆盖）
-        local mcp_ak="${MINIO_AI_ACCESS_KEY:-fwh-toolbox-ai}"
-        local mcp_sk="${MINIO_AI_SECRET_KEY:-fwh-toolbox-ai}"
-
-        if command -v python3 >/dev/null 2>&1; then
-            APP_ENV="${APP_ENV}" PG_DSN="${pg_dsn}" MONGO_DSN="${MONGO_DSN}" \
-            REDIS_ADDR="${REDIS_ADDR}" MYSQL_DSN="${MYSQL_DSN}" \
-            MINIO_ENDPOINT="${MINIO_ENDPOINT}" MINIO_ACCESS_KEY="${mcp_ak}" \
-            MINIO_SECRET_KEY="${mcp_sk}" MINIO_BUCKET="${MINIO_BUCKET}" \
-            python3 - "${GEN_MCP_CONFIG}" <<'PY'
-import os, re, sys
-path = sys.argv[1]
-repl = {
-    "APP_ENV":            os.environ["APP_ENV"],
-    "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"],
-}
-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:
-        out.append(f'{m.group(2)}="{repl[m.group(2)]}"')
-    else:
-        out.append(line)
-open(path, "w", encoding="utf-8").write("\n".join(out) + "\n")
-print("config.mcp.env 已生成")
-PY
-        else
-            warn "未找到 python3，改用 sed 简易替换（含特殊字符时请手工核对）"
-            _sed_mcp() { sed -i -E "s#^(${1})=.*#${1}=\"${2//#/\\#}\"#" "${GEN_MCP_CONFIG}"; }
-            _sed_mcp APP_ENV "${APP_ENV}"
-            _sed_mcp POSTGRES_DSN "${pg_dsn}"
-            _sed_mcp MONGO_DSN "${MONGO_DSN}"
-            _sed_mcp REDIS_ADDR "${REDIS_ADDR}"
-            [[ -n "${MYSQL_DSN}" ]] && _sed_mcp MYSQL_DSN "${MYSQL_DSN}"
-            _sed_mcp MINIO_ENDPOINT "${MINIO_ENDPOINT}"
-            _sed_mcp MINIO_ACCESS_KEY "${mcp_ak}"
-            _sed_mcp MINIO_SECRET_KEY "${mcp_sk}"
-            _sed_mcp MINIO_BUCKET_NAME "${MINIO_BUCKET}"
-        fi
-        ok "已生成配置：${GEN_MCP_CONFIG}"
-    else
-        warn "未找到 ${MCP_CONFIG_EXAMPLE}，跳过 config.mcp.env 生成"
-    fi
 }
 
 # ---------------------------------------------------------------------------
@@ -644,8 +545,7 @@ build_backend() {
     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/ )
+        && GOOS=linux GOARCH=amd64 go build -o "${APP_NAME}" ./ )
     ok "后端构建完成"
 }
 
@@ -667,13 +567,11 @@ prepare_remote_stage() {
     fi
     scp_to "${SCRIPT_DIR}/install_pgadmin.sh" "${REMOTE_STAGE}/scripts/"
     scp_to "${SCRIPT_DIR}/provision_minio.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
@@ -683,12 +581,6 @@ prepare_remote_stage() {
         rm -f /tmp/fwh-dist.tgz
     fi
     [[ -n "${GEN_CONFIG}" ]] && scp_to "${GEN_CONFIG}" "${REMOTE_STAGE}/config.env"
-    if [[ -n "${GEN_MCP_CONFIG}" ]]; then
-        scp_to "${GEN_MCP_CONFIG}" "${REMOTE_STAGE}/config.mcp.env"
-    elif [[ -n "${GEN_CONFIG}" ]]; then
-        # 回退：未单独生成 MCP 配置时沿用后端配置
-        scp_to "${GEN_CONFIG}" "${REMOTE_STAGE}/config.mcp.env"
-    fi
     ok "产物已上传到远程 ${REMOTE_STAGE}"
 }
 
@@ -755,9 +647,9 @@ step_minioacct() {
          MINIO_ROOT_USER='${MINIO_ROOT_USER}' MINIO_ROOT_PASSWORD='$(printf '%s' "${MINIO_ROOT_PASSWORD}")' \
          MINIO_ACCESS_KEY='${MINIO_ACCESS_KEY:-fwh-toolbox}' MINIO_SECRET_KEY='$(printf '%s' "${MINIO_SECRET_KEY:-fwh-toolbox}")' \
          MINIO_AI_ACCESS_KEY='${MINIO_AI_ACCESS_KEY}' MINIO_AI_SECRET_KEY='$(printf '%s' "${MINIO_AI_SECRET_KEY}")' \
-         MINIO_BUCKET='${MINIO_BUCKET}' MINIO_AI_BUCKET='${MINIO_AI_BUCKET}' \
+         MINIO_BUCKET='${MINIO_BUCKET}' \
          bash '${base}/provision_minio.sh'"
-    ok "MinIO 业务账号步骤结束（后端 ${MINIO_ACCESS_KEY:-fwh-toolbox} / MCP ${MINIO_AI_ACCESS_KEY}）"
+    ok "MinIO 业务账号步骤结束（后端 ${MINIO_ACCESS_KEY:-fwh-toolbox} / AI 助手 ${MINIO_AI_ACCESS_KEY}）"
 }
 
 # ---------------------------------------------------------------------------
@@ -778,21 +670,6 @@ step_caddy() {
     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 安装步骤结束"
-}
-
 # ---------------------------------------------------------------------------
 # 初始化数据库
 # ---------------------------------------------------------------------------
@@ -831,23 +708,15 @@ step_backend() {
     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}' && \
+             sudo chmod +x '${server_dir}/${APP_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; }"
+             { [ -f '${REMOTE_STAGE}/config.env' ] && sudo cp '${REMOTE_STAGE}/config.env' '${server_dir}/config.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}"
+        sudo chmod +x "${server_dir}/${APP_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
-        if [[ -n "${GEN_MCP_CONFIG}" ]]; then
-            sudo cp "${GEN_MCP_CONFIG}" "${server_dir}/config.mcp.env" || true
-        elif [[ -n "${GEN_CONFIG}" ]]; then
-            sudo cp "${GEN_CONFIG}" "${server_dir}/config.mcp.env" || true
-        fi
     fi
 
     # 写入 systemd 服务
@@ -897,7 +766,6 @@ step_frontend() {
 # ---------------------------------------------------------------------------
 cleanup() {
     [[ -n "${GEN_CONFIG}" && -f "${GEN_CONFIG}" ]] && rm -f "${GEN_CONFIG}"
-    [[ -n "${GEN_MCP_CONFIG}" && -f "${GEN_MCP_CONFIG}" ]] && rm -f "${GEN_MCP_CONFIG}"
     if [[ "${MODE}" == "remote" ]]; then
         ssh_run "rm -rf ${REMOTE_STAGE}" >/dev/null 2>&1 || true
     fi
@@ -908,7 +776,7 @@ summary() {
     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 ' )$( [[ ${DO_PGADMIN} == y ]] && echo -n 'pgAdmin4 ' )$( [[ ${DO_MINIOACCT} == y ]] && echo -n 'MinIO账号 ' )"
+    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_PGADMIN} == y ]] && echo -n 'pgAdmin4 ' )$( [[ ${DO_MINIOACCT} == y ]] && echo -n 'MinIO账号 ' )"
     echo
     echo "后续："
     if [[ "${DO_CADDY}" == "y" ]]; then
@@ -921,17 +789,6 @@ summary() {
         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
     if [[ "${DO_PGADMIN}" == "y" ]]; then
         echo "  * pgAdmin4 已部署：http://${PGADMIN_BIND}:${PGADMIN_PORT}（登录 ${PGADMIN_EMAIL}）"
         echo "    新建 Server 连本机 PG：主机 host.docker.internal、端口 ${PG_PORT}、用户 postgres。"
@@ -940,8 +797,8 @@ summary() {
     fi
     if [[ "${DO_MINIOACCT}" == "y" ]]; then
         echo "  * MinIO 业务账号已创建：后端 ${MINIO_ACCESS_KEY:-fwh-toolbox}（写 fwh-toolbox* 桶）、"
-        echo "    MCP ${MINIO_AI_ACCESS_KEY}（写 fwh-toolbox-ai* 桶，其余只读）。"
-        echo "    确认 config.env 用后端账号、config.mcp.env 用 AI 账号；核对：mc admin user list fwhlocal"
+        echo "    AI 助手 ${MINIO_AI_ACCESS_KEY}（读 fwh-toolbox 桶）。"
+        echo "    确认 config.env 用后端账号、config.agent-mcp.env 用 AI 账号；核对：mc admin user list fwhlocal"
     fi
     echo "  * 验证：curl http://127.0.0.1:${APP_PORT}/swagger/index.html"
     if [[ "${MODE}" == "remote" ]]; then
@@ -958,7 +815,7 @@ FranklinWH Toolbox 交互式一键部署
 用法：
   $0            进入交互式向导（选择 local/remote，分步选择与填写）
   $0 --only <项[,项...]>  只执行指定步骤（仍会先问 local/remote 与该步骤参数）
-                可选项：deps casdoor initdb minioacct pgadmin caddy kiro deploy
+                可选项：deps casdoor initdb minioacct pgadmin caddy deploy
                 例：$0 --only caddy   或   $0 --only deps,initdb
   $0 --help     显示本帮助
 
@@ -969,26 +826,25 @@ FranklinWH Toolbox 交互式一键部署
   3. 生成 config.env
   4. 本地构建前端 dist 与后端二进制
   5. （远程）打包上传产物与辅助脚本
-  6. 检测/安装依赖 → 安装 Casdoor → 初始化数据库 → 部署后端 → 部署前端 → 配置 Caddy → 安装 Kiro CLI
+  6. 检测/安装依赖 → 安装 Casdoor → 初始化数据库 → 部署后端 → 部署前端 → 配置 Caddy
 
 可选步骤（向导中勾选）：
   * 检测/安装数据库引擎与依赖（PostgreSQL/MongoDB/Redis/MinIO/Docker）
   * 安装 Casdoor（Docker，认证服务）
   * 安装并配置 Caddy 反向代理（生成站点 Caddyfile 并 reload）
-  * 安装 Kiro CLI（后端 AI 对话依赖，以运行用户安装并登录 Builder ID）
 EOF
 }
 
 # --only 解析：把所有步骤关掉，再按传入项打开对应步骤
-#   支持项：deps casdoor initdb minioacct pgadmin caddy kiro deploy
+#   支持项：deps casdoor initdb minioacct pgadmin caddy deploy
 #   多项用逗号分隔，如 --only deps,initdb
 parse_only() {
     local items="$1"
-    [[ -n "${items}" ]] || { err "--only 需要指定步骤，如：--only caddy（可选 deps,casdoor,initdb,minioacct,pgadmin,caddy,kiro,deploy）"; exit 1; }
+    [[ -n "${items}" ]] || { err "--only 需要指定步骤，如：--only caddy（可选 deps,casdoor,initdb,minioacct,pgadmin,caddy,deploy）"; exit 1; }
 
     # 全部关闭
     DO_DEPS="n"; DO_CASDOOR="n"; DO_INITDB="n"; DO_BACKEND="n"; DO_FRONTEND="n"
-    DO_GENCONF="n"; DO_CADDY="n"; DO_KIRO="n"; DO_PGADMIN="n"; DO_MINIOACCT="n"
+    DO_GENCONF="n"; DO_CADDY="n"; DO_PGADMIN="n"; DO_MINIOACCT="n"
 
     ONLY_MODE=1
     ONLY_LABEL="${items}"
@@ -1002,7 +858,6 @@ parse_only() {
             minioacct) DO_MINIOACCT="y" ;;
             pgadmin)   DO_PGADMIN="y" ;;
             caddy)     DO_CADDY="y" ;;
-            kiro)      DO_KIRO="y" ;;
             deploy)
                 # 部署前后端：子交互选择范围
                 echo "部署范围：1) 前端+后端(all)  2) 仅后端  3) 仅前端"
@@ -1035,7 +890,7 @@ main() {
 
     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} pgadmin=${DO_PGADMIN} minio-acct=${DO_MINIOACCT}"
+    echo "步骤：deps=${DO_DEPS} casdoor=${DO_CASDOOR} initdb=${DO_INITDB} backend=${DO_BACKEND} frontend=${DO_FRONTEND} genconf=${DO_GENCONF} caddy=${DO_CADDY} pgadmin=${DO_PGADMIN} minio-acct=${DO_MINIOACCT}"
     ask_yn "确认开始执行？" "y" || { warn "已取消"; exit 0; }
 
     generate_config
@@ -1050,7 +905,6 @@ main() {
     step_backend
     step_frontend
     step_caddy
-    step_kiro
     summary
 }
 

deploy/start.sh

@@ -39,8 +39,7 @@ echo -e "  ${c_bold}4)${c_reset} 仅创建 MinIO 账号与策略（fwh-toolbox /
 echo -e "  ${c_bold}5)${c_reset} 仅部署 pgAdmin4（+ 给 postgres 设密码）"
 echo -e "  ${c_bold}6)${c_reset} 仅安装 Casdoor（Docker 认证服务）"
 echo -e "  ${c_bold}7)${c_reset} 仅部署 Caddy 反向代理（自编译 + spaceship DNS）"
-echo -e "  ${c_bold}8)${c_reset} 仅安装 Kiro CLI"
-echo -e "  ${c_bold}9)${c_reset} 仅构建部署前后端（可选前端/后端/两者）"
+echo -e "  ${c_bold}8)${c_reset} 仅构建部署前后端（可选前端/后端/两者）"
 echo -e "  ${c_bold}0)${c_reset} 退出"
 echo
 
@@ -56,8 +55,7 @@ while :; do
         5) exec bash "${SETUP}" --only pgadmin ;;
         6) exec bash "${SETUP}" --only casdoor ;;
         7) exec bash "${SETUP}" --only caddy ;;
-        8) exec bash "${SETUP}" --only kiro ;;
-        9) exec bash "${SETUP}" --only deploy ;;
+        8) exec bash "${SETUP}" --only deploy ;;
         0) echo -e "${c_green}已退出${c_reset}"; exit 0 ;;
         *) echo -e "${c_red}无效选择：${sel}，请重新输入（0 退出）。${c_reset}" >&2 ;;
     esac