diff --git a/.workbuddy/memory/2026-11-03.md b/.workbuddy/memory/2026-11-03.md index e0841aa..bc88859 100644 --- a/.workbuddy/memory/2026-11-03.md +++ b/.workbuddy/memory/2026-11-03.md @@ -158,3 +158,36 @@ ⚠️ 必须同步做:① 新增 **AR14**(`sspf-mcp-adapter` 之外不许依赖 compat 包); ② `check-contract-scan.py` 的 `plat_files` 必须收 `crates/sspf-mcp-adapter/src/`(守卫常量在里面,漏收 ⇒ CC6 假漂移); ③ `check-boundary.sh` 的 CP1/CP2 纳入 MCP 适配层真源;④ 重跑全部 `--self-test`。 + +--- + +## M6 完成 —— MCP 适配层下沉(`crates/sspf-mcp-adapter`,tag `v0.1.6-m6`) + +- **迁入**:`src/backend/src/mcp_{adapter,compat}.rs`(共 3,283 行)→ `crates/sspf-mcp-adapter/`; + 原路径变 5 行转发壳(`pub use sspf_mcp_adapter::::*;`)⇒ `--mcp` 启动路径与集成测试**零感知**。 +- **依赖**(比计划瘦):`sspf-mcp` + `sspf-core` + **仅四个** compat 域包 + (`system`/`permission`/`workflow`/`online_dev`)+ `sspf-lowcode` + `sspf-lowcode-exec` + `axum` + `pglite-rs`。 + ⇒ 原计划写「所有 compat 包」,实际 `msg`/`ext`/`compat-core` **不必依赖**(少三条边)。 + 另**未提权任何 `pub(crate)`**。 +- **路径改写**(只改前缀、模块名不动 —— M5 的教训): + `crate::platform::compat::<域>::…` → `sspf_compat_<域>::<域>::…`(**多一段模块名**); + `crate::lowcode_crud::…` → `sspf_lowcode_exec::lowcode_crud::…`;`crate::mcp_compat::…` 不动(同 crate)。 +- **闸门**: + - `check-arch.sh` 新增 **AR14**(依赖白名单 + 源码不许 `use sspf_pack_*`);反自证 **9/9** + (注入越界依赖 `sspf-contract` + 业务包引用,**按路径分别验**)。 + - `check-boundary.sh` 新增 `MCP_ADAPTER` ⇒ CP1/CP2 纳入适配层真源; + **另加 CP1'' 扫描面反自证**(往新 crate 注入业务包真实表名 ⇒ 必须被抓到)—— + 这是「显式列目录的扫描面」的自保手段,抓不到 = 扫描面漏了新 crate = 尺子已废。 + - `check-contract-scan.py` **不用改**(适配层是**调用方**不是端点实现方 ⇒ CC1–CC10 不受影响)。 + - 契约 `[RULER]` 的 `check-boundary.sh` 由 11 改 **12**(尺子自证主动抓到的条数变化)。 +- 🔴 **本批的发现(闸门暴露的既有问题)**:把新 crate 纳入 CP1 扫描面后,CP1 **立刻抓到 5 处 + 业务标识符泄漏**(`permission.asset.dataResource`×2 / `asset/DataResource`×2 / `asset_data_resource`×1)—— + 在 `mcp_adapter.rs` 的 **hint 提示语**与**单测断言**里,此前不在扫描面内所以一直隐形。 + ⇒ 已改成通用形态(`permission.<模块>.<资源>` / `<模块>/<资源>` / `data_resource`)。 + **这正是「闸门必须与迁移同步改」的价值**。 +- **数字**:`cargo build` 零警告;`cargo test` **695/0**(与 M1 基线完全一致);`check-arch` **19/19**; + `--self-test` **9/9**;`check-boundary` **12/12**;`check-contract` 10/10(反自证 12 例全过); + `check-module` 123/123;`check-citations` 4/4;`check-naming` 3/0/1。 +- ⏭ **下一步 = M7(收口)**:删 `platform/` 转发壳、全仓 import 改 `sspf_core::…` / `sspf_compat_<域>::…`、 + 拆 `tests/`(单测随代码进 crate、集成测试留壳测装配)、补全最终闸门。 + ⚠️ M7 是**大爆炸改动**(编译器报几百处)⇒ 必须先打 tag、可回滚。 diff --git a/CLAUDE.md b/CLAUDE.md index 373c0d3..a6d2a56 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -113,7 +113,9 @@ ssw-platform/ │ ├── sspf-lowcode-exec/ # 🔴 低代码**执行层**(M5):连库/跑 SQL/校验/回写模型 │ │ # `src/backend/src/lowcode_*.rs` 只是转发壳 │ ├── sspf-plugin/ # (P3)业务包加载器:静态 / dylib / wasm -│ └── sspf-mcp/ # (P1)MCP 2.0 元工具层 +│ ├── sspf-mcp/ # (P1)MCP 2.0 元工具层 +│ └── sspf-mcp-adapter/ # (M6)MCP 适配层:NativeAdapter + 契约面 handler 直调 +│ # 壳侧 `src/backend/src/mcp_{adapter,compat}.rs` 只是转发壳 ├── packs/ # 【业务包】整目录可搬(jnpf ⇄ sspf 双向) │ └── asset/ # 样板:Cargo.toml + pack.toml + src/lib.rs │ # 只依赖 sspf-sdk(AR2)⇒ 可独立 cargo build @@ -135,6 +137,8 @@ ssw-platform/ │ │ │ │ ├── demo.rs / shop.rs / books.rs # 模板模块(不进生产) │ │ │ │ ├── asset.rs # 🔴 真实业务:DataResource(数据资源,本体对齐) │ │ │ │ └── .rs # 尚数网业务模块(Phase 3 起) +│ │ │ ├── mcp_adapter.rs # 【MCP 适配层】M6 起真源在 `crates/sspf-mcp-adapter/src/` +│ │ │ ├── mcp_compat.rs # 这里两个 .rs 只是转发壳(`pub use sspf_mcp_adapter::::*;`) │ │ │ ├── routes.rs # 路由装配(平台 27 条 + 面 B 14 条 + merge 业务路由) │ │ │ └── bootstrap.rs # 【装配根】唯一同时认识两层;把业务菜单注入种子 │ │ ├── db/schema.sql # 完整 DDL(base_* 8 + 业务 N) diff --git a/Cargo.lock b/Cargo.lock index 1bc221b..0f7c677 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1241,6 +1241,24 @@ dependencies = [ "tokio", ] +[[package]] +name = "sspf-mcp-adapter" +version = "0.1.0" +dependencies = [ + "axum", + "pglite-rs", + "serde_json", + "serde_urlencoded", + "sspf-compat-online_dev", + "sspf-compat-permission", + "sspf-compat-system", + "sspf-compat-workflow", + "sspf-core", + "sspf-lowcode", + "sspf-lowcode-exec", + "sspf-mcp", +] + [[package]] name = "sspf-pack-asset" version = "0.1.0" @@ -1305,6 +1323,7 @@ dependencies = [ "sspf-lowcode", "sspf-lowcode-exec", "sspf-mcp", + "sspf-mcp-adapter", "sspf-pack-asset", "sspf-plugin", "sspf-store", diff --git a/HANDOFF.md b/HANDOFF.md index f183562..4d6a158 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -263,6 +263,58 @@ M2/M3 搬迁后闸门都报红(正常),M4 首次跑就 10/10 ⇒ 反而是 --- +## 0-0-pre7. 2026-11-03 20:40 **M6 完成**:MCP 适配层下沉(tag `v0.1.6-m6`) + +**做了什么**:`src/backend/src/mcp_{adapter,compat}.rs`(共 3,283 行)下沉到 `crates/sspf-mcp-adapter/`, +原路径全变 5 行转发壳(`pub use sspf_mcp_adapter::::*;`)⇒ **`--mcp` 启动路径与集成测试零感知**。 + +| 依赖 | 为什么 | +|---|---| +| `sspf-mcp` | `PlatformAdapter` / `ToolError` / `EnvInfo` —— 工具契约层 | +| `sspf-core` | `AppState` / `Db` / `ids::new_uuid` / `cipher::md5_hex` / `envelope::ActionResult` | +| `sspf-compat-{system,permission,workflow,online_dev}` | `mcp_compat.rs` **直调它们的 handler**(与 HTTP 路由同一个函数 ⇒ 语义零漂移) | +| `sspf-lowcode` + `sspf-lowcode-exec` | 动态 CRUD 工具:解析设计稿(纯计算)+ 连库执行 | +| `axum` | handler 的 extractor(`State` / `Path` / `RawQuery` / `HeaderMap`)与 `Json` | +| `pglite-rs` | `ToSql` 参数绑定(把 JSON 值转成 SQL 参数) | + +**与原计划的差异**:原计划写「依赖 sspf-mcp + sspf-core + sspf-compat-*」, +实际只依赖**四个** compat 域包(`system` / `permission` / `workflow` / `online_dev`)—— +`mcp_compat.rs` 真正调到的就这四个域,`msg` / `ext` / `compat-core` **不必依赖**(少三个边 ⇒ 依赖图更瘦)。 +另外**未提权任何 `pub(crate)`**(两个文件的对外接口本来就是 `pub`)。 + +**跨 crate 路径改写**(🔴 只改**前缀**、模块名不动 —— M5 的教训): +- `crate::platform::db::valid_table` → `sspf_core::db::valid_table` +- `crate::platform::state::AppState` → `sspf_core::state::AppState` +- `crate::platform::compat::workflow::…` → `sspf_compat_workflow::workflow::…`(**多一段模块名**) +- `crate::lowcode_crud::…` → `sspf_lowcode_exec::lowcode_crud::…` +- `crate::mcp_compat::…` **不动**(同 crate 内) + +**闸门改造**: +- `check-arch.sh` 新增 **AR14**(两层:依赖白名单 + 源码不许 `use sspf_pack_*`);反自证 **9/9** + (**两处都注入**:越界依赖 `sspf-contract` + 业务包引用 `use sspf_pack_asset::…`,且**按路径分别验**)。 +- `check-boundary.sh` 新增 `MCP_ADAPTER` ⇒ **CP1**(业务标识符)/ **CP2**(`use crate::modules`)纳入适配层真源。 + **另加 CP1'' 扫描面反自证**:往新 crate 注入业务包真实表名 ⇒ 必须被抓到(抓不到 = 扫描面漏了新 crate = 尺子已废)。 +- `check-contract-scan.py` **不用改** —— 契约面 handler 的真源仍在 `sspf-compat-*` 各包, + 适配层只是**调用方**(不是端点实现方)⇒ CC1–CC10 不受影响(实测 10/10,反自证 12 例全过)。 + +**🔴 本批的发现(闸门暴露的既有问题)**: +把新 crate 纳入 CP1 扫描面后,CP1 **立刻抓到 5 处业务标识符泄漏** +(`permission.asset.dataResource` × 2 / `asset/DataResource` × 2 / `asset_data_resource` × 1)—— +它们在 `mcp_adapter.rs` 的 **hint 提示语**与**单测断言**里,此前**不在扫描面内**所以一直隐形。 +⇒ 已改成**通用形态**(`permission.<模块>.<资源>` / `<模块>/<资源>` / `data_resource`)。 +**这正是「闸门必须与迁移同步改」的价值**:不扩扫描面 ⇒ 这 5 处会跟着代码搬进 crates 继续潜伏。 + +**出口判据(全部达成)**: +`cargo build --workspace` 零警告;`cargo test --workspace` = **695 passed / 0 failed**(与 M1 基线完全一致); +`check-arch` **19/19**;`--self-test` **9/9**;`check-boundary` **12/12**(契约登记已同步改为 12); +`check-contract` 10/10(反自证 12 例全过);`check-module` 123/123;`check-citations` 4/4;`check-naming` 3/0/1。 + +**⏭ 下一步 = M7(收口)**:删 `platform/` 转发壳、全仓 import 改成 `sspf_core::…` / `sspf_compat_<域>::…`、 +拆 `tests/`(单元测试随代码进 crate、集成测试留壳测装配)、补全最终闸门。 +⚠️ M7 是**大爆炸改动**(编译器会报几百处)⇒ 必须先打 tag、可回滚。 + +--- + ## 0-0. 2026-11-02 23:13 验证修复轮(官方前端 + dacli 真跑后修的) 用官方 vue 前端 + dacli + 586 条端点探针做过一轮真实系统性验证(报告: diff --git a/crates/sspf-mcp-adapter/Cargo.toml b/crates/sspf-mcp-adapter/Cargo.toml new file mode 100644 index 0000000..53cf278 --- /dev/null +++ b/crates/sspf-mcp-adapter/Cargo.toml @@ -0,0 +1,56 @@ +[package] +name = "sspf-mcp-adapter" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 **MCP 适配层**(M6 起从 `src/backend/src/mcp_{adapter,compat}.rs` 下沉到这里)。 +# +# 装什么: +# - `mcp_adapter.rs`(2,652 行)—— 进程内直调 `AppState` 的 `NativeAdapter` +# (`sspf_mcp::PlatformAdapter` 的内核侧实现); +# - `mcp_compat.rs`(631 行)—— 对**契约面 handler** 的进程内直调 +# (造管理员头 → 直接调 `sspf_compat_*` 的 handler → 把 `ActionResult` 转成 `ToolError`)。 +# +# 🔴 **为什么单独成 crate**:它是「MCP 适配」这一项独立能力 —— 既不是平台核心 +# (`sspf-core`),也不是契约面(`sspf-compat-*`),也不是低代码执行层 +# (`sspf-lowcode-exec`)。它站在这四者**之上**,把它们编排成一个 `PlatformAdapter`。 +# +# 🔴 **它是全仓唯一「知道全部包」的 crate**: +# `mcp_compat.rs` 要直调 workflow / system / permission / online_dev 四个域的 +# handler ⇒ 它依赖**所有**契约面包。这在依赖图上是**顶层汇聚点**, +# 不是环(被依赖方谁都不认识它)⇒ 方向依然单一。 +# +# 🔴 **依赖纪律**(AR14 钉住): +# - 允许:MCP 工具层(`sspf-mcp`)+ 平台核心(`sspf-core`)+ 契约面各域包 +# + 低代码引擎(`sspf-lowcode`)+ 低代码执行层(`sspf-lowcode-exec`) +# + `axum`(handler 的 extractor / 信封)+ `pglite-rs`(`ToSql` 参数绑定)。 +# - 禁止:**业务包**(`sspf_pack_*`)—— 适配层不许认识任何业务。 +# - 禁止:`sspf-contract`(**不直接依赖**)—— 契约类型由 `sspf-core` / `sspf-mcp` 转出。 +[dependencies] +# MCP 工具层(`PlatformAdapter` / `ToolError` / `EnvInfo`) +sspf-mcp = { path = "../sspf-mcp" } + +# 平台核心(AppState / Db / ids / cipher / 信封 / 会话表) +sspf-core = { path = "../sspf-core" } + +# 契约面四个域包(`mcp_compat.rs` 直调它们的 handler) +sspf-compat-system = { path = "../sspf-compat-system" } +sspf-compat-permission = { path = "../sspf-compat-permission" } +sspf-compat-workflow = { path = "../sspf-compat-workflow" } +sspf-compat-online_dev = { path = "../sspf-compat-online_dev" } + +# 低代码引擎(纯计算:解析 / 校验设计稿) +sspf-lowcode = { path = "../sspf-lowcode" } + +# 低代码执行层(连库 / 跑 SQL / 回写模型 —— `mcp_adapter` 的动态 CRUD 工具要用) +sspf-lowcode-exec = { path = "../sspf-lowcode-exec" } + +# HTTP 提取器与信封(handler 的入参类型 / `Json`) +axum = { workspace = true } + +# 真实库(`ToSql` 参数绑定 —— 把 JSON 值转成 SQL 参数) +pglite-rs = { workspace = true } + +serde_json = { workspace = true } +serde_urlencoded = { workspace = true } diff --git a/crates/sspf-mcp-adapter/src/lib.rs b/crates/sspf-mcp-adapter/src/lib.rs new file mode 100644 index 0000000..5fad5e9 --- /dev/null +++ b/crates/sspf-mcp-adapter/src/lib.rs @@ -0,0 +1,44 @@ +//! sspf-mcp-adapter —— **MCP 适配层**:把平台能力包成 MCP 工具。 +//! +//! M6 起从 `src/backend/src/mcp_{adapter,compat}.rs` 下沉到这里 +//! (见 `docs/CRATES-MIGRATION.md` §4 M6)。 +//! +//! ## 模块 +//! +//! | 模块 | 干什么 | +//! |---|---| +//! | [`mcp_adapter`] | [`NativeAdapter`] —— 进程内直调 `AppState`,实现 `sspf_mcp::PlatformAdapter` | +//! | [`mcp_compat`] | 对**契约面 handler** 的进程内直调(造管理员头 + 转 `ToolError`) | +//! +//! ## 🔴 为什么「MCP 与 HTTP 是同一套实现」 +//! +//! MCP 与 HTTP 是同一套能力的两个入口。若 MCP 自己拼 SQL,两边会**双份实现**: +//! 校验规则、默认值、软删语义、审计列都会各写一遍 ⇒ 必然漂移 +//! (dacli 踩过:50+ 处漂移修了 6 周)。 +//! ⇒ 这里**不重写**,直接调契约面 handler(与 HTTP 路由注册的是同一个函数), +//! 语义天然一致。 +//! +//! ## 🔴 依赖方向(单向,无环) +//! +//! ```text +//! sspf-mcp-adapter ──▶ sspf-mcp (工具契约层) +//! ──▶ sspf-core (平台核心:AppState / Db / ids / cipher) +//! ──▶ sspf-compat-* (契约面各域:handler 直调对象) +//! ──▶ sspf-lowcode (低代码引擎:纯计算) +//! ──▶ sspf-lowcode-exec(低代码执行层:连库 / 跑 SQL) +//! ``` +//! +//! 🔴 **它是全仓唯一「知道全部包」的 crate** —— `mcp_compat.rs` 直调四个契约面域包 +//! 的 handler ⇒ 依赖图上它是**顶层汇聚点**。这不是环:被依赖方(`sspf-core` / +//! `sspf-compat-*` / `sspf-mcp`)谁都不认识它 ⇒ 方向依然单一。 +//! +//! ## 🔴 依赖纪律(AR14 钉住) +//! +//! | 允许 | 禁止 | +//! |---|---| +//! | MCP 工具层 / 平台核心 / 契约面各域包 / 低代码两层 | **业务包**(`sspf_pack_*`)—— 适配层不认识业务 | + +pub mod mcp_adapter; +pub mod mcp_compat; + +pub use mcp_adapter::NativeAdapter; diff --git a/crates/sspf-mcp-adapter/src/mcp_adapter.rs b/crates/sspf-mcp-adapter/src/mcp_adapter.rs new file mode 100644 index 0000000..557976a --- /dev/null +++ b/crates/sspf-mcp-adapter/src/mcp_adapter.rs @@ -0,0 +1,2652 @@ +//! mcp_adapter —— 内核侧实现 `sspf_mcp::PlatformAdapter`(**进程内直调**)。 +//! +//! ## 为什么放在内核里,而不是 sspf-mcp 里 +//! +//! 依赖方向是 `kernel → sspf-mcp → sspf-contract`(见 `PLAN.md` §3.2 AR5)。 +//! MCP 层不认识 `AppState`、不认识 `Db` —— 所以「怎么拿数据」只能由内核实现。 +//! +//! 好处是同一个 `sspf-mcp` 还能被 `BaselineHttpAdapter` 复用(P4 对账时打 Java 后端), +//! 两边的工具契约完全一致。 +//! +//! ## 为什么不走 HTTP 回环 +//! +//! `--mcp` 形态与 HTTP 形态**共用同一个 `AppState`**(同库、同连接、同会话表)。 +//! 走 HTTP 会多一层序列化 + 需要额外端口 + 需要先登录拿 token, +//! 而 AI 本地驱动开发时没有「登录」这个概念 —— 它就是这个进程的主人。 +//! +//! ## 🔴 但没有权限上下文 +//! +//! 进程内直调意味着**绕过登录与菜单守卫**。这在本地开发是特性(AI 就是管理员), +//! 在多用户部署是风险。⇒ 未来若把 MCP 暴露到网络,必须走 `BaselineHttpAdapter` +//! 带上真实 token,不能用本适配器。 + +use std::collections::HashSet; + +use pglite::ToSql; +use serde_json::{json, Value}; + +use sspf_core::db::valid_table; +use sspf_core::state::AppState; + +use sspf_mcp::adapter::{BoxFut, EnvInfo, PlatformAdapter, ToolError}; + +/// 进程内适配器。 +pub struct NativeAdapter { + state: AppState, +} + +impl NativeAdapter { + /// 用装配好的状态构造。 + pub fn new(state: AppState) -> Self { + Self { state } + } + + /// 取主系统 id(`base_system.f_is_main=1`),查不到就回落常量。 + async fn main_system_id(&self) -> String { + self.state + .db + .scalar_text("SELECT f_id FROM base_system WHERE f_is_main = 1 LIMIT 1") + .await + .ok() + .flatten() + .unwrap_or_else(|| "mainSystem".to_string()) + } + + /// 数当前 schema 下的表(健康检查口径,与 `/api/health` 一致)。 + async fn table_count(&self) -> usize { + self.state + .db + .scalar_text( + "SELECT count(*)::text FROM information_schema.tables \ + WHERE table_schema = 'public' AND table_type = 'BASE TABLE'", + ) + .await + .ok() + .flatten() + .and_then(|s| s.parse().ok()) + .unwrap_or(0) + } + + /// 取一张表的全部列名(白名单来源)。 + /// + /// 🔴 这是 `data.query` / `data.count` 的**唯一安全边界**: + /// 表名、列名、排序字段都必须先在这里查到,才允许进 SQL。 + /// 参数化只能防「值注入」,防不了「结构注入」。 + async fn columns_of(&self, table: &str) -> Result, ToolError> { + let t = table.to_string(); + let rows = self + .state + .db + .query_json_params( + "SELECT column_name AS \"name\" FROM information_schema.columns \ + WHERE table_schema = 'public' AND table_name = $1 \ + ORDER BY ordinal_position", + &[&t], + ) + .await + .map_err(db_err)?; + + Ok(rows + .into_iter() + .filter_map(|r| r["name"].as_str().map(str::to_string)) + .collect()) + } + + /// 把结构化的 `where` 数组拼成 SQL 片段;**值全部进 `params`**,列名必须过白名单。 + /// + /// 占位符编号 = `params` 的长度(`$1` 起),所以调用方要先把前置参数 push 进去。 + fn build_where( + conds: &[Value], + allowed: &HashSet, + params: &mut Vec, + ) -> Result { + let mut clauses: Vec = Vec::new(); + + for c in conds { + let col = c.get("column").and_then(Value::as_str).unwrap_or(""); + if !allowed.contains(col) { + return Err(ToolError::new( + "UNKNOWN_COLUMN", + format!("列不存在: {col}"), + ) + .field("where.column") + .hint("先 schema.table.describe 确认列名(列名是 f_ 前缀)")); + } + let qcol = format!("\"{col}\""); + let op = c.get("op").and_then(Value::as_str).unwrap_or("eq"); + + match op { + "isnull" => clauses.push(format!("{qcol} IS NULL")), + "notnull" => clauses.push(format!("{qcol} IS NOT NULL")), + sym @ ("eq" | "ne" | "like" | "gt" | "ge" | "lt" | "le") => { + let mut v = c + .get("value") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + if sym == "like" { + v = format!("%{v}%"); + } + params.push(v); + let n = params.len(); + let sql_op = match sym { + "eq" => "=", + "ne" => "<>", + "like" => "ILIKE", + "gt" => ">", + "ge" => ">=", + "lt" => "<", + _ => "<=", + }; + clauses.push(format!("{qcol} {sql_op} ${n}")); + } + other => { + return Err(ToolError::new( + "BAD_OPERATOR", + format!("不支持的比较符: {other}"), + ) + .field("where.op") + .hint("可用:eq / ne / like / gt / ge / lt / le / isnull / notnull")) + } + } + } + + Ok(if clauses.is_empty() { + String::new() + } else { + format!(" AND {}", clauses.join(" AND ")) + }) + } + + // ---------------------------------------------------------------- 权限 + + async fn role_list(&self, args: &Value) -> Result { + let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); + let enabled_only = args + .get("enabledOnly") + .and_then(Value::as_bool) + .unwrap_or(true); + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); + + let mut params: Vec = Vec::new(); + let mut extra = String::new(); + if !keyword.is_empty() { + params.push(format!("%{keyword}%")); + let n = params.len(); + extra.push_str(&format!( + " AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})" + )); + } + if enabled_only { + extra.push_str(" AND f_enabled_mark = 1"); + } + + let sql = format!( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_type AS \"type\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\" \ + FROM base_role WHERE f_delete_mark = 0{extra} \ + ORDER BY f_sort_code, f_full_name LIMIT {limit}" + ); + + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ "count": rows.len(), "roles": rows })) + } + + async fn user_list(&self, args: &Value) -> Result { + let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); + let organize = args + .get("organizeId") + .and_then(Value::as_str) + .unwrap_or(""); + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); + + let mut params: Vec = Vec::new(); + let mut extra = String::new(); + if !keyword.is_empty() { + params.push(format!("%{keyword}%")); + let n = params.len(); + extra.push_str(&format!( + " AND (f_account ILIKE ${n} OR f_real_name ILIKE ${n} OR f_mobile_phone ILIKE ${n})" + )); + } + if !organize.is_empty() { + params.push(organize.to_string()); + let n = params.len(); + extra.push_str(&format!(" AND f_organize_id = ${n}")); + } + + // 🔴 绝不选 f_password / f_secretkey + let sql = format!( + "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \ + COALESCE(f_mobile_phone, '') AS \"mobilePhone\", \ + COALESCE(f_organize_id, '') AS \"organizeId\", \ + COALESCE(f_role_id, '') AS \"roleId\", \ + COALESCE(f_is_administrator, 0) AS \"isAdministrator\", \ + COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + COALESCE(f_lock_mark, 0) AS \"lockMark\" \ + FROM base_user WHERE f_delete_mark = 0{extra} \ + ORDER BY f_account LIMIT {limit}" + ); + + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ "count": rows.len(), "users": rows })) + } + + async fn authorize_list(&self, args: &Value) -> Result { + let object_type = args + .get("objectType") + .and_then(Value::as_str) + .unwrap_or(""); + let object_id = args.get("objectId").and_then(Value::as_str).unwrap_or(""); + + if object_type.is_empty() || object_id.is_empty() { + return Err(ToolError::new( + "MISSING_ARG", + "objectType 与 objectId 都必填", + ) + .field("objectType") + .hint("先 permission.role.list 拿 roleId,或用 permission.user.list 拿 userId")); + } + + let (ot, oid) = (object_type.to_string(), object_id.to_string()); + let rows = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_item_type AS \"itemType\", f_item_id AS \"itemId\", \ + f_object_type AS \"objectType\", f_object_id AS \"objectId\" \ + FROM base_authorize \ + WHERE f_delete_mark = 0 AND f_object_type = $1 AND f_object_id = $2 \ + ORDER BY f_item_type, f_item_id", + &[&ot, &oid], + ) + .await + .map_err(db_err)?; + + // 只查了「直授」这一源,提示 AI 别忘了另外三源 + Ok(json!({ + "count": rows.len(), + "objectType": ot, + "objectId": oid, + "items": rows, + "note": "这里只有**直授**;实际权限是四源合并(直授 + 角色 + 组织 + 岗位),管理员短路", + })) + } + + // ---------------------------------------------------------------- 字典 + + async fn dict_type_list(&self, args: &Value) -> Result { + let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); + + let mut params: Vec = Vec::new(); + let mut extra = String::new(); + if !keyword.is_empty() { + params.push(format!("%{keyword}%")); + let n = params.len(); + extra.push_str(&format!( + " AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})" + )); + } + + // 🔴 `f_type` 是 **INTEGER**(官方 DDL)—— `COALESCE(f_type, '')` 会报 + // `invalid input syntax for type integer: ""`。默认值必须是 0 不是空串。 + let sql = format!( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + COALESCE(f_type, 0) AS \"type\", COALESCE(f_is_tree, 0) AS \"isTree\", \ + COALESCE(f_enabled_mark, 0) AS \"enabledMark\" \ + FROM base_dictionary_type WHERE f_delete_mark = 0{extra} \ + ORDER BY f_sort_code, f_full_name LIMIT {limit}" + ); + + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ "count": rows.len(), "types": rows })) + } + + async fn dict_data_list(&self, args: &Value) -> Result { + let type_id = args + .get("dictionaryTypeId") + .and_then(Value::as_str) + .unwrap_or(""); + if type_id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "缺少 dictionaryTypeId") + .field("dictionaryTypeId") + .hint("先 dict.type.list 拿分类 id")); + } + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(100).clamp(1, 500); + + let tid = type_id.to_string(); + let sql = format!( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + COALESCE(f_is_default, 0) AS \"isDefault\", \ + COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\" \ + FROM base_dictionary_data \ + WHERE f_delete_mark = 0 AND f_dictionary_type_id = $1 \ + ORDER BY f_sort_code, f_full_name LIMIT {limit}" + ); + + let rows = self + .state + .db + .query_json_params(&sql, &[&tid]) + .await + .map_err(db_err)?; + + Ok(json!({ + "dictionaryTypeId": tid, + "count": rows.len(), + "items": rows, + })) + } + + // ---------------------------------------------------------------- 数据 + + async fn data_query(&self, args: &Value) -> Result { + let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); + let table = valid_table(raw).ok_or_else(|| { + ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")) + .field("table") + .hint("只接受小写字母/数字/下划线") + .next("schema.table.list", json!({}), "先列出所有表") + })?; + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(20).clamp(1, 200); + + let cols = self.columns_of(&table).await?; + if cols.is_empty() { + return Err(ToolError::new("TABLE_NOT_FOUND", format!("表 {table} 不存在")) + .field("table") + .next("schema.table.list", json!({}), "确认表名")); + } + + // 🔴 口令/密钥列**不许经通用读口子投影**(红线⑤)。 + // `data.query` 是「按表名读任意表」的通用口子:不挡这里, + // 一句 `{"table":"base_user"}` 就能把全库口令哈希拖走(实测会返回 password)。 + let readable: Vec = cols + .iter() + .filter(|c| !is_sensitive_column(c)) + .cloned() + .collect(); + let allowed: HashSet = readable.iter().cloned().collect(); + let n_hidden = cols.len() - readable.len(); + + // 选列:缺省全选(已滤掉敏感列);显式给了就逐个校验 + let select = match args.get("columns").and_then(Value::as_array) { + Some(arr) if !arr.is_empty() => { + let mut v = Vec::with_capacity(arr.len()); + for c in arr { + let name = c.as_str().unwrap_or(""); + ensure_not_sensitive(name, "columns")?; + if !allowed.contains(name) { + return Err(ToolError::new( + "UNKNOWN_COLUMN", + format!("列不存在: {name}"), + ) + .field("columns") + .hint("先 schema.table.describe 看列名")); + } + v.push(format!("\"{name}\"")); + } + v.join(", ") + } + _ => readable + .iter() + .map(|c| format!("\"{c}\"")) + .collect::>() + .join(", "), + }; + + // 条件 + let conds = args + .get("where") + .and_then(Value::as_array) + .cloned() + .unwrap_or_default(); + for c in &conds { + let col = c.get("column").and_then(Value::as_str).unwrap_or(""); + ensure_not_sensitive(col, "where.column")?; + } + let mut params: Vec = Vec::new(); + let where_sql = Self::build_where(&conds, &allowed, &mut params)?; + + // 排序(列名同样走白名单) + let order_sql = match args.get("orderBy").and_then(Value::as_str) { + Some(ob) if !ob.is_empty() => { + ensure_not_sensitive(ob, "orderBy")?; + if !allowed.contains(ob) { + return Err(ToolError::new("UNKNOWN_COLUMN", format!("排序列不存在: {ob}")) + .field("orderBy")); + } + let dir = if args.get("desc").and_then(Value::as_bool).unwrap_or(true) { + "DESC" + } else { + "ASC" + }; + format!(" ORDER BY \"{ob}\" {dir}") + } + _ => String::new(), + }; + + // table 已过 valid_table(仅 [a-z0-9_])⇒ 双引号包裹安全 + let sql = format!( + "SELECT {select} FROM \"{table}\" WHERE 1 = 1{where_sql}{order_sql} LIMIT {limit}" + ); + + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ + "table": table, + "count": rows.len(), + "limit": limit, + // 🔴 明说「藏着几列」—— 否则 AI 会以为这张表就这么多列 + "hiddenColumns": n_hidden, + "rows": rows, + })) + } + + async fn data_count(&self, args: &Value) -> Result { + let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); + let table = valid_table(raw).ok_or_else(|| { + ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")).field("table") + })?; + + let cols = self.columns_of(&table).await?; + if cols.is_empty() { + return Err(ToolError::new("TABLE_NOT_FOUND", format!("表 {table} 不存在")) + .field("table")); + } + let allowed: HashSet = cols.into_iter().collect(); + + let conds = args + .get("where") + .and_then(Value::as_array) + .cloned() + .unwrap_or_default(); + for c in &conds { + let col = c.get("column").and_then(Value::as_str).unwrap_or(""); + ensure_not_sensitive(col, "where.column")?; + } + let mut params: Vec = Vec::new(); + let where_sql = Self::build_where(&conds, &allowed, &mut params)?; + + let sql = format!("SELECT count(*)::text AS \"count\" FROM \"{table}\" WHERE 1 = 1{where_sql}"); + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + let count = rows + .first() + .and_then(|r| r["count"].as_str()) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0); + + Ok(json!({ "table": table, "count": count })) + } + + // ---------------------------------------------------------------- 索引 + + async fn index_list(&self, args: &Value) -> Result { + let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); + let table = if raw.is_empty() { + None + } else { + Some(valid_table(raw).ok_or_else(|| { + ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")).field("table") + })?) + }; + + let rows = match &table { + Some(t) => { + let tt = t.clone(); + self.state + .db + .query_json_params( + "SELECT tablename AS \"table\", indexname AS \"name\", indexdef AS \"definition\" \ + FROM pg_indexes WHERE schemaname = 'public' AND tablename = $1 \ + ORDER BY indexname", + &[&tt], + ) + .await + } + None => { + self.state + .db + .query_json( + "SELECT tablename AS \"table\", indexname AS \"name\", indexdef AS \"definition\" \ + FROM pg_indexes WHERE schemaname = 'public' \ + ORDER BY tablename, indexname", + ) + .await + } + } + .map_err(db_err)?; + + Ok(json!({ "count": rows.len(), "indexes": rows })) + } + + // ---------------------------------------------------------------- 写:菜单 + + /// 解析 `App-Code` → `base_system.f_id`。 + async fn system_id_of(&self, code: &str) -> Result { + let c = code.to_string(); + let rows = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_system WHERE f_en_code = $1 LIMIT 1", + &[&c], + ) + .await + .map_err(db_err)?; + + rows.first() + .and_then(|r| r["id"].as_str()) + .map(str::to_string) + .ok_or_else(|| { + ToolError::new("SYSTEM_NOT_FOUND", format!("应用不存在: {code}")) + .field("systemEnCode") + .hint("主系统的 App-Code 是 `mainSystem`") + }) + } + + /// 建菜单 —— 写**完整 14 列**(含 `f_en_code` / `f_system_id`)。 + /// + /// 🔴 与 `sys.rs::module_save` 的差异见 `tools/write.rs` 顶部说明: + /// HTTP 侧那条只写 12 列,缺的两列正好是「面 B 权限判据」与「多应用隔离」。 + async fn menu_create(&self, args: &Value) -> Result { + let full_name = args + .get("fullName") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if full_name.is_empty() { + return Err(ToolError::new("MISSING_ARG", "fullName 不能为空").field("fullName")); + } + let en_code = args + .get("enCode") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if en_code.is_empty() { + return Err(ToolError::new("MISSING_ARG", "enCode 不能为空") + .field("enCode") + .hint("形如 permission.<模块>.<资源>")); + } + if !en_code.contains('.') { + return Err(ToolError::new( + "BAD_EN_CODE", + format!("enCode 必须带域前缀: {en_code}"), + ) + .field("enCode") + .hint("形如 permission.<模块>.<资源>")); + } + + let url = args + .get("urlAddress") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if url.is_empty() { + return Err(ToolError::new("MISSING_ARG", "urlAddress 不能为空").field("urlAddress")); + } + if url.starts_with('/') { + return Err(ToolError::new( + "BAD_URL_ADDRESS", + format!("urlAddress 不要前导斜杠: {url}"), + ) + .field("urlAddress") + .hint("写 `<模块>/<资源>`,不要前导斜杠")); + } + if !url + .chars() + .all(|c| c.is_ascii_alphanumeric() || matches!(c, '/' | '_' | '-')) + { + return Err(ToolError::new("BAD_URL_ADDRESS", "urlAddress 只能含字母数字与 / _ -") + .field("urlAddress")); + } + + let parent_id = args + .get("parentId") + .and_then(Value::as_str) + .unwrap_or("0") + .to_string(); + let menu_type = args.get("type").and_then(Value::as_i64).unwrap_or(2); + if !matches!(menu_type, 1 | 2) { + return Err(ToolError::new("BAD_TYPE", "type 只能是 1(目录)或 2(页面)") + .field("type")); + } + let icon = args.get("icon").and_then(Value::as_str).map(str::to_string); + let sort_code = args.get("sortCode").and_then(Value::as_i64).unwrap_or(0); + let sys_code = args + .get("systemEnCode") + .and_then(Value::as_str) + .unwrap_or("mainSystem") + .to_string(); + + let system_id = self.system_id_of(&sys_code).await?; + + // 父菜单必须存在(除根) + if parent_id != "0" { + let pid = parent_id.clone(); + let hit = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_module \ + WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&pid], + ) + .await + .map_err(db_err)?; + if hit.is_empty() { + return Err(ToolError::new( + "PARENT_NOT_FOUND", + format!("父菜单不存在: {parent_id}"), + ) + .field("parentId") + .next("menu.tree", json!({"flat": true}), "先看现有菜单 id")); + } + } + + // 🔴 en_code / url_address 在官方 DDL 里**没有 UNIQUE** ⇒ 必须应用层查重 + let dup = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"name\", \ + COALESCE(f_en_code, '') AS \"enCode\", \ + COALESCE(f_url_address, '') AS \"urlAddress\" \ + FROM base_module \ + WHERE f_delete_mark = 0 AND f_system_id = $1 \ + AND (f_en_code = $2 OR f_url_address = $3) LIMIT 1", + &[&system_id, &en_code, &url], + ) + .await + .map_err(db_err)?; + if let Some(row) = dup.first() { + let same_code = row["enCode"].as_str() == Some(en_code.as_str()); + return Err(ToolError::new( + "MENU_EXISTS", + format!( + "{} 已存在:{}(id={})", + if same_code { "enCode" } else { "urlAddress" }, + row["name"].as_str().unwrap_or(""), + row["id"].as_str().unwrap_or("") + ), + ) + .field(if same_code { "enCode" } else { "urlAddress" }) + .hint("换一个编码/路径,或先删掉旧菜单(menu.delete)") + .next("menu.tree", json!({"flat": true}), "确认是不是同一个菜单")); + } + + let id = sspf_core::ids::new_uuid(); + let vals: Vec> = vec![ + Some(id.clone()), + Some("0".to_string()), // f_tenant_id:本期单租户 + Some(full_name.clone()), + Some(en_code.clone()), + Some(url.clone()), + Some(parent_id.clone()), + Some(menu_type.to_string()), + None, // f_category:VARCHAR 分类,缺省 NULL + icon, + Some(sort_code.to_string()), + Some("1".to_string()), // f_enabled_mark + Some("0".to_string()), // f_delete_mark + Some(system_id.clone()), + ]; + let refs: Vec<&(dyn ToSql + Sync)> = + vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + + // 🔴 `now()` 直接写进 SQL(不占参数位,避免 `$n` 序号错位) + self.state + .db + .exec_params( + "INSERT INTO base_module \ + (f_id, f_tenant_id, f_full_name, f_en_code, f_url_address, f_parent_id, \ + f_type, f_category, f_icon, f_sort_code, f_enabled_mark, f_delete_mark, \ + f_system_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ + $7::text::integer, $8::text, $9::text, $10::text::bigint, \ + $11::text::integer, $12::text::integer, $13::text, now())", + &refs, + ) + .await + .map_err(db_err)?; + + Ok(json!({ + "id": id, + "fullName": full_name, + "enCode": en_code, + "urlAddress": url, + "systemId": system_id, + "next": "菜单已建,但**非管理员还看不到** —— 需要给角色授权(base_authorize)", + })) + } + + /// 软删菜单(只置 `f_delete_mark`,不动物理行)。 + async fn menu_delete(&self, args: &Value) -> Result { + let id = args.get("id").and_then(Value::as_str).unwrap_or("").trim(); + if id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "id 不能为空") + .field("id") + .next("menu.tree", json!({"flat": true}), "先查菜单 id")); + } + let mid = id.to_string(); + + let hit = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"name\" FROM base_module \ + WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&mid], + ) + .await + .map_err(db_err)?; + let Some(row) = hit.first() else { + return Err(ToolError::new("MENU_NOT_FOUND", format!("菜单不存在或已删除: {id}")) + .field("id") + .next("menu.tree", json!({"flat": true}), "确认 id")); + }; + let name = row["name"].as_str().unwrap_or("").to_string(); + + self.state + .db + .exec_params( + "UPDATE base_module SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1 AND f_delete_mark = 0", + &[&mid], + ) + .await + .map_err(db_err)?; + + Ok(json!({ + "deleted": true, + "id": mid, + "fullName": name, + "note": "软删:物理行还在(迁移靠 --data-only,物理删会丢历史)。子菜单不级联。", + })) + } + + // ---------------------------------------------------------------- 写:字典 + + async fn dict_type_create(&self, args: &Value) -> Result { + let full_name = args + .get("fullName") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let en_code = args + .get("enCode") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if full_name.is_empty() || en_code.is_empty() { + return Err(ToolError::new("MISSING_ARG", "fullName 与 enCode 都必填") + .field("fullName")); + } + if !en_code + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_') + { + return Err(ToolError::new( + "BAD_EN_CODE", + format!("enCode 只能含小写字母/数字/下划线: {en_code}"), + ) + .field("enCode") + .hint("用 `order_status` 这种,不要中文或连字符")); + } + + let dict_type = args.get("type").and_then(Value::as_i64).unwrap_or(1); + let is_tree = if args.get("isTree").and_then(Value::as_bool).unwrap_or(false) { + 1i64 + } else { + 0i64 + }; + let parent_id = args + .get("parentId") + .and_then(Value::as_str) + .unwrap_or("0") + .to_string(); + let sort_code = args.get("sortCode").and_then(Value::as_i64).unwrap_or(0); + + // en_code 查重(同表内) + let ec = en_code.clone(); + let dup = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_dictionary_type \ + WHERE f_delete_mark = 0 AND f_en_code = $1 LIMIT 1", + &[&ec], + ) + .await + .map_err(db_err)?; + if let Some(row) = dup.first() { + return Err(ToolError::new( + "DICT_EXISTS", + format!("字典编码已存在: {en_code}(id={})", row["id"].as_str().unwrap_or("")), + ) + .field("enCode") + .next("dict.type.list", json!({"keyword": en_code}), "确认是否同一个")); + } + + let id = sspf_core::ids::new_uuid(); + let vals: Vec> = vec![ + Some(id.clone()), + Some("0".to_string()), + Some(parent_id), + Some(full_name.clone()), + Some(en_code.clone()), + Some(is_tree.to_string()), + Some(dict_type.to_string()), + None, // f_description + Some("1".to_string()), // f_enabled_mark + Some(sort_code.to_string()), + Some("0".to_string()), // f_delete_mark + ]; + let refs: Vec<&(dyn ToSql + Sync)> = + vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + + self.state + .db + .exec_params( + "INSERT INTO base_dictionary_type \ + (f_id, f_tenant_id, f_parent_id, f_full_name, f_en_code, f_is_tree, f_type, \ + f_description, f_enabled_mark, f_sort_code, f_delete_mark, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, \ + $6::text::integer, $7::text::integer, $8::text, \ + $9::text::integer, $10::text::bigint, $11::text::integer, now())", + &refs, + ) + .await + .map_err(db_err)?; + + Ok(json!({ + "id": id, + "fullName": full_name, + "enCode": en_code, + "note": "分类已建;字典**项**(下拉选项)P2 通过 dict.data.create 补", + })) + } + + // ---------------------------------------------------------------- 授权(第四批:闭环) + + /// `base_authorize.f_object_type` → 真实表名。 + /// + /// 🔴 **硬编码映射,不走 `valid_table`**:这里的表名是代码常量, + /// 用户输入只贡献 enum 值,拼不出任意表名 —— 这是比字符串白名单更强的保证。 + fn object_table(object_type: &str) -> Option<&'static str> { + match object_type { + "user" => Some("base_user"), + "role" => Some("base_role"), + "organize" => Some("base_organize"), + "position" => Some("base_position"), + _ => None, + } + } + + /// 解析要授权的菜单:`menuId` 优先,否则 `menuEnCode` + 应用过滤。 + /// + /// 返回 `(id, fullName, enCode)`。 + async fn resolve_menu(&self, args: &Value) -> Result<(String, String, String), ToolError> { + let menu_id = args + .get("menuId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let menu_en_code = args + .get("menuEnCode") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + if menu_id.is_empty() && menu_en_code.is_empty() { + return Err(ToolError::new( + "MISSING_ARG", + "menuId 与 menuEnCode 至少给一个", + ) + .field("menuId") + .hint("menuId 来自 menu.tree;menuEnCode 是建菜单时写的 permission.x.y") + .next("menu.tree", json!({"flat": true}), "先查菜单 id 与编码")); + } + + let rows = if !menu_id.is_empty() { + let mid = menu_id.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\" \ + FROM base_module WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&mid], + ) + .await + .map_err(db_err)? + } else { + // 按编码查时要限定应用:不同应用可以存在同 en_code 的菜单,跨应用授权等于授错对象。 + let sys_code = args + .get("systemEnCode") + .and_then(Value::as_str) + .unwrap_or("mainSystem") + .to_string(); + let system_id = self.system_id_of(&sys_code).await?; + let ec = menu_en_code.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\" \ + FROM base_module \ + WHERE f_en_code = $1 AND f_system_id = $2 AND f_delete_mark = 0 LIMIT 1", + &[&ec, &system_id], + ) + .await + .map_err(db_err)? + }; + + let Some(row) = rows.first() else { + let what = if menu_id.is_empty() { + format!("enCode={menu_en_code}(应用 {})", args + .get("systemEnCode") + .and_then(Value::as_str) + .unwrap_or("mainSystem")) + } else { + format!("id={menu_id}") + }; + return Err(ToolError::new("MENU_NOT_FOUND", format!("菜单不存在或已删除: {what}")) + .field(if menu_id.is_empty() { "menuEnCode" } else { "menuId" }) + .hint("P0:同 enCode 在不同应用是不同菜单,确认 systemEnCode 对不对") + .next("menu.tree", json!({"flat": true}), "列出当前应用的菜单")); + }; + + Ok(( + row["id"].as_str().unwrap_or("").to_string(), + row["fullName"].as_str().unwrap_or("").to_string(), + row["enCode"].as_str().unwrap_or("").to_string(), + )) + } + + /// `permission.authorize.grant` —— 幂等:已授权则原样返回,不重复插行。 + async fn authorize_grant(&self, args: &Value) -> Result { + let object_type = args + .get("objectType") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let Some(table) = Self::object_table(&object_type) else { + return Err(ToolError::new( + "BAD_OBJECT_TYPE", + format!("objectType 只能是 user / role / organize / position,收到 `{object_type}`"), + ) + .field("objectType") + .hint("推荐 role(一改全组生效);user 只用于临时特批,逐人维护成本高")); + }; + + let object_id = args + .get("objectId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if object_id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "objectId 不能为空") + .field("objectId") + .hint(format!( + "用主键 id,不是账号/名称(permission.{} 拿)", + if object_type == "user" { "user" } else { "role" }.to_string() + + ".list" + ))); + } + + // 授权对象必须真实存在:插一条指向不存在 id 的行,不报错但永远不生效。 + let obj_rows = self + .state + .db + .query_json_params( + &format!( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"name\" \ + FROM {table} WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1" + ), + &[&object_id], + ) + .await + .map_err(db_err)?; + if obj_rows.is_empty() { + return Err(ToolError::new( + "OBJECT_NOT_FOUND", + format!("{object_type} 不存在或已删除: {object_id}"), + ) + .field("objectId") + .hint("objectId 是主键,不是账号/角色名") + .next( + format!("permission.{}.list", if object_type == "user" { "user" } else { "role" }), + json!({}), + "先列表拿真实 id", + )); + } + let object_name = obj_rows[0]["name"].as_str().unwrap_or("").to_string(); + + let (menu_id, menu_name, menu_en_code) = self.resolve_menu(args).await?; + + // 幂等:已有未删的同三元组 ⇒ 直接返回,不插重复行。 + let dup = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_authorize \ + WHERE f_item_type = 'module' AND f_item_id = $1 \ + AND f_object_type = $2 AND f_object_id = $3 AND f_delete_mark = 0 LIMIT 1", + &[&menu_id, &object_type, &object_id], + ) + .await + .map_err(db_err)?; + if let Some(row) = dup.first() { + return Ok(json!({ + "granted": false, + "alreadyGranted": true, + "authorizeId": row["id"].as_str().unwrap_or(""), + "objectType": object_type, + "objectId": object_id, + "menuId": menu_id, + "note": "该授权已存在(幂等,未重复插入)", + })); + } + + let id = sspf_core::ids::new_uuid(); + let vals: Vec> = vec![ + Some(id.clone()), + Some("0".to_string()), // f_tenant_id + Some("module".to_string()), // f_item_type + Some(menu_id.clone()), + Some(object_type.clone()), + Some(object_id.clone()), + Some("0".to_string()), // f_sort_code + Some("0".to_string()), // f_delete_mark + ]; + let refs: Vec<&(dyn ToSql + Sync)> = + vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + + self.state + .db + .exec_params( + "INSERT INTO base_authorize \ + (f_id, f_tenant_id, f_item_type, f_item_id, f_object_type, f_object_id, \ + f_sort_code, f_delete_mark, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ + $7::text::bigint, $8::text::integer, now())", + &refs, + ) + .await + .map_err(db_err)?; + + Ok(json!({ + "granted": true, + "authorizeId": id, + "objectType": object_type, + "objectId": object_id, + "objectName": object_name, + "menuId": menu_id, + "menuName": menu_name, + "menuEnCode": menu_en_code, + "next": "用 permission.effective 复核是否真的生效(四源并集 ∩ 当前应用)", + })) + } + + /// `permission.authorize.revoke` —— 软删;撤不存在的行要报错(不静默成功)。 + async fn authorize_revoke(&self, args: &Value) -> Result { + let object_type = args + .get("objectType") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if Self::object_table(&object_type).is_none() { + return Err(ToolError::new( + "BAD_OBJECT_TYPE", + format!("objectType 只能是 user / role / organize / position,收到 `{object_type}`"), + ) + .field("objectType")); + } + let object_id = args + .get("objectId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if object_id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "objectId 不能为空").field("objectId")); + } + + let (menu_id, menu_name, _) = self.resolve_menu(args).await?; + + let hit = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_authorize \ + WHERE f_item_type = 'module' AND f_item_id = $1 \ + AND f_object_type = $2 AND f_object_id = $3 AND f_delete_mark = 0 LIMIT 1", + &[&menu_id, &object_type, &object_id], + ) + .await + .map_err(db_err)?; + let Some(row) = hit.first() else { + // 🔴 不静默成功:撤一条不存在的授权,最常见原因是 objectId 用错了(账号 vs id)。 + return Err(ToolError::new( + "AUTHORIZE_NOT_FOUND", + format!("没有这条授权:{object_type}={object_id} → {menu_name}"), + ) + .field("objectId") + .hint("objectId 是主键;用 permission.authorize.list 确认这条授权到底存不存在")); + }; + let auth_id = row["id"].as_str().unwrap_or("").to_string(); + + self.state + .db + .exec_params( + "UPDATE base_authorize SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1 AND f_delete_mark = 0", + &[&auth_id], + ) + .await + .map_err(db_err)?; + + Ok(json!({ + "revoked": true, + "authorizeId": auth_id, + "objectType": object_type, + "objectId": object_id, + "menuId": menu_id, + "menuName": menu_name, + "note": "只撤这一源;用户仍可能通过角色/组织/岗位拿到同一菜单 ⇒ 用 permission.effective 复核", + })) + } + + /// 查某个对象(user/role/…)被直授的菜单 id 列表。 + async fn authorized_modules( + &self, + object_type: &str, + object_id: &str, + ) -> Result, ToolError> { + let rows = self + .state + .db + .query_json_params( + "SELECT f_item_id AS \"itemId\" FROM base_authorize \ + WHERE f_item_type = 'module' AND f_object_type = $1 AND f_object_id = $2 \ + AND f_delete_mark = 0", + &[&object_type, &object_id], + ) + .await + .map_err(db_err)?; + Ok(rows + .iter() + .filter_map(|r| r["itemId"].as_str().map(str::to_string)) + .filter(|s| !s.is_empty()) + .collect()) + } + + /// `permission.effective` —— 四源并集 + 按应用过滤,两组数都给。 + /// + /// 🔴 这是「授权了但看不见」的唯一诊断入口:能把「没授上」和 + /// 「授上了但不在这个应用」区分开,省掉反复 grep 数据库。 + async fn permission_effective(&self, args: &Value) -> Result { + let user_id = args + .get("userId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let account = args + .get("account") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + if user_id.is_empty() && account.is_empty() { + return Err(ToolError::new( + "MISSING_ARG", + "userId 与 account 至少给一个", + ) + .field("userId") + .hint("userId 是主键;不知道 id 就传 account,工具内部换算") + .next("permission.user.list", json!({}), "列出用户拿 id")); + } + + // 解析用户(id 优先) + let user_rows = if !user_id.is_empty() { + let uid = user_id.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_account,'') AS \"account\", \ + COALESCE(f_is_administrator, 0) AS \"isAdmin\" \ + FROM base_user WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&uid], + ) + .await + .map_err(db_err)? + } else { + let acc = account.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_account,'') AS \"account\", \ + COALESCE(f_is_administrator, 0) AS \"isAdmin\" \ + FROM base_user WHERE f_account = $1 AND f_delete_mark = 0 LIMIT 1", + &[&acc], + ) + .await + .map_err(db_err)? + }; + let Some(urow) = user_rows.first() else { + return Err(ToolError::new( + "USER_NOT_FOUND", + format!( + "用户不存在: {}", + if user_id.is_empty() { &account } else { &user_id } + ), + ) + .field(if user_id.is_empty() { "account" } else { "userId" }) + .next("permission.user.list", json!({}), "列出用户确认账号")); + }; + let uid = urow["id"].as_str().unwrap_or("").to_string(); + let uaccount = urow["account"].as_str().unwrap_or("").to_string(); + let is_admin = urow["isAdmin"].as_i64().unwrap_or(0) == 1; + + let sys_code = args + .get("systemEnCode") + .and_then(Value::as_str) + .unwrap_or("mainSystem") + .to_string(); + let system_id = self.system_id_of(&sys_code).await?; + let with_detail = args + .get("withMenuDetail") + .and_then(Value::as_bool) + .unwrap_or(false); + + // ---- 四源各自收集(保留来源,才能回答「这条权限从哪来」)---- + let direct = self.authorized_modules("user", &uid).await?; + + let role_ids: Vec = { + let u = uid.clone(); + self.state + .db + .query_json_params( + "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ + WHERE f_object_type = 'user' AND f_object_id = $1", + &[&u], + ) + .await + .map_err(db_err)? + .iter() + .filter_map(|r| r["roleId"].as_str().map(str::to_string)) + .filter(|s| !s.is_empty()) + .collect() + }; + let mut from_roles: Vec = Vec::new(); + for rid in &role_ids { + from_roles.extend(self.authorized_modules("role", rid).await?); + } + + let relation_ids = |object_type: &'static str| { + let u = uid.clone(); + let ot = object_type.to_string(); + let db = self.state.db.clone(); + async move { + db.query_json_params( + "SELECT f_object_id AS \"objectId\" FROM base_user_relation \ + WHERE f_user_id = $1 AND f_object_type = $2", + &[&u, &ot], + ) + .await + .map(|rows| { + rows.iter() + .filter_map(|r| r["objectId"].as_str().map(str::to_string)) + .filter(|s| !s.is_empty()) + .collect::>() + }) + } + }; + + let organize_ids: Vec = relation_ids("organize").await.map_err(db_err)?; + let mut from_orgs: Vec = Vec::new(); + for oid in &organize_ids { + from_orgs.extend(self.authorized_modules("organize", oid).await?); + } + + let position_ids: Vec = relation_ids("position").await.map_err(db_err)?; + let mut from_positions: Vec = Vec::new(); + for pid in &position_ids { + from_positions.extend(self.authorized_modules("position", pid).await?); + } + + // ---- 并集(去重)---- + use std::collections::BTreeSet; + let mut union: BTreeSet = BTreeSet::new(); + for group in [&direct, &from_roles, &from_orgs, &from_positions] { + union.extend(group.iter().cloned()); + } + + // ---- 当前应用内的菜单(按 system_id 过滤 + 未软删)---- + let sys = system_id.clone(); + let sys_menus = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_url_address,'') AS \"urlAddress\", \ + COALESCE(f_en_code,'') AS \"enCode\" \ + FROM base_module WHERE f_system_id = $1 AND f_delete_mark = 0", + &[&sys], + ) + .await + .map_err(db_err)?; + + let sys_ids: BTreeSet = sys_menus + .iter() + .filter_map(|r| r["id"].as_str().map(str::to_string)) + .collect(); + + if is_admin { + // 管理员短路:守卫直接放行,不看授权表。 + let mut menus: Vec = sys_menus; + if !with_detail { + menus = menus + .iter() + .map(|m| json!(m["id"].as_str().unwrap_or(""))) + .collect(); + } + return Ok(json!({ + "userId": uid, + "account": uaccount, + "isAdmin": true, + "systemId": system_id, + "mode": "admin-bypass", + "visible": { "count": sys_ids.len(), "menus": menus }, + "note": "管理员短路:守卫在第一条判据就返回 true,与 base_authorize 无关", + })); + } + + let visible_ids: BTreeSet = union.intersection(&sys_ids).cloned().collect(); + + let visible_menus: Vec = if with_detail { + sys_menus + .iter() + .filter(|m| { + m["id"] + .as_str() + .is_some_and(|id| visible_ids.contains(id)) + }) + .cloned() + .collect() + } else { + visible_ids.iter().map(|id| json!(id)).collect() + }; + + Ok(json!({ + "userId": uid, + "account": uaccount, + "isAdmin": false, + "systemId": system_id, + "sources": { + "direct": { "objectIds": [], "menuIds": direct }, + "role": { "objectIds": role_ids, "menuIds": dedup(&from_roles) }, + "organize": { "objectIds": organize_ids, "menuIds": dedup(&from_orgs) }, + "position": { "objectIds": position_ids, "menuIds": dedup(&from_positions) }, + }, + "fourSource": { "count": union.len(), "menuIds": union.iter().cloned().collect::>() }, + "visible": { "count": visible_ids.len(), "menus": visible_menus }, + "explain": "fourSource 是四源并集(授权表不带应用维度);visible 再与当前应用的菜单求交。\ + 两者不一致说明有授权指向了别的应用的菜单(或菜单已删)。", + })) + } + + /// `permission.user.create` —— 建普通用户(可同时绑角色)。 + /// + /// 🔴 存在的唯一理由:**验证授权闭环必须有一个非管理员账号**。 + /// 管理员走 `is_admin` 短路,永远看得见,用 admin 测菜单可见性等于没测。 + /// + /// 🔴 刻意不开放建管理员:`isAdministrator` 被硬编码为 0, + /// 入参只接受 false。让 AI 顺手造超管是难以回收的权限风险。 + async fn user_create(&self, args: &Value) -> Result { + let account = args + .get("account") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if account.is_empty() { + return Err(ToolError::new("MISSING_ARG", "account 不能为空").field("account")); + } + if account.len() > 50 + || !account + .chars() + .next() + .is_some_and(|c| c.is_ascii_alphabetic()) + || !account + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_') + { + return Err(ToolError::new( + "BAD_ACCOUNT", + format!("account 只能字母开头 + 字母数字下划线,且 ≤50 字符: {account}"), + ) + .field("account") + .hint("如 zhangsan、li_si01")); + } + + let real_name = args + .get("realName") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if real_name.is_empty() { + return Err(ToolError::new("MISSING_ARG", "realName 不能为空").field("realName")); + } + + let password = args + .get("password") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + if password.len() < 6 { + return Err(ToolError::new("BAD_PASSWORD", "password 至少 6 位") + .field("password") + .hint("传**明文**,工具内部算 md5 存库;传 md5 会导致登录永远失败")); + } + + // 🔴 软删的账号也算占用:否则「删了重建」会让历史授权指向新 id, + // 出现「新建的人莫名其妙有一堆权限」。 + let dup = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_delete_mark,0) AS \"deleted\" \ + FROM base_user WHERE f_account = $1 LIMIT 1", + &[&account], + ) + .await + .map_err(db_err)?; + if let Some(row) = dup.first() { + let deleted = row["deleted"].as_i64().unwrap_or(0) == 1; + return Err(ToolError::new( + "ACCOUNT_EXISTS", + format!( + "账号已存在{}: {account}", + if deleted { "(已软删,仍占用)" } else { "" } + ), + ) + .field("account") + .hint(if deleted { + "软删的账号仍占用编码;换一个账号,或在库里恢复原账号" + } else { + "换一个账号" + }) + .next("permission.user.list", json!({"keyword": account}), "先确认是不是同一个人")); + } + + // 角色必须存在(绑到不存在的角色 = 一条永远不生效的关系行) + let role_ids: Vec = args + .get("roleIds") + .and_then(Value::as_array) + .map(|a| { + a.iter() + .filter_map(Value::as_str) + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect() + }) + .unwrap_or_default(); + for rid in &role_ids { + let r = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_role WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[rid], + ) + .await + .map_err(db_err)?; + if r.is_empty() { + return Err(ToolError::new( + "ROLE_NOT_FOUND", + format!("角色不存在: {rid}"), + ) + .field("roleIds") + .hint("roleIds 是角色主键(如 role_user),不是角色名") + .next("permission.role.list", json!({}), "列出角色拿真实 id")); + } + } + + let gender = args + .get("gender") + .and_then(Value::as_str) + .unwrap_or("unknown") + .to_string(); + let mobile = args + .get("mobilePhone") + .and_then(Value::as_str) + .map(str::to_string); + let email = args + .get("email") + .and_then(Value::as_str) + .map(str::to_string); + + let id = sspf_core::ids::new_uuid(); + let pwd_md5 = sspf_core::cipher::md5_hex(&password); + + let vals: Vec> = vec![ + Some(id.clone()), + Some("0".to_string()), // f_tenant_id + Some(account.clone()), + Some(real_name.clone()), + Some(gender), + mobile, + email, + Some(pwd_md5), + Some("0".to_string()), // f_is_administrator —— 硬编码,不开放 + Some("1".to_string()), // f_enabled_mark + Some("0".to_string()), // f_delete_mark + Some("0".to_string()), // f_sort_code + ]; + let refs: Vec<&(dyn ToSql + Sync)> = + vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + + self.state + .db + .exec_params( + "INSERT INTO base_user \ + (f_id, f_tenant_id, f_account, f_real_name, f_gender, f_mobile_phone, f_email, \ + f_password, f_is_administrator, f_enabled_mark, f_delete_mark, f_sort_code, \ + f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, $7::text, \ + $8::text, $9::text::integer, $10::text::integer, $11::text::integer, \ + $12::text::bigint, now())", + &refs, + ) + .await + .map_err(db_err)?; + + // 绑角色(base_role_relation:用户标识在 f_object_id,不在 f_user_id) + for rid in &role_ids { + let rel_id = sspf_core::ids::new_uuid(); + let rvals: Vec> = vec![ + Some(rel_id), + Some("0".to_string()), // f_tenant_id + Some(rid.clone()), // f_role_id + Some("user".to_string()), // f_object_type + Some(id.clone()), // f_object_id + Some("0".to_string()), // f_sort_code + Some("0".to_string()), // f_delete_mark + ]; + let rrefs: Vec<&(dyn ToSql + Sync)> = + rvals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + self.state + .db + .exec_params( + "INSERT INTO base_role_relation \ + (f_id, f_tenant_id, f_role_id, f_object_type, f_object_id, \ + f_sort_code, f_delete_mark, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, \ + $6::text::bigint, $7::text::integer, now())", + &rrefs, + ) + .await + .map_err(db_err)?; + } + + Ok(json!({ + "id": id, + "account": account, + "realName": real_name, + "isAdministrator": false, + "roleIds": role_ids, + "note": "口令已转 md5 存库,明文不落地。用 non-admin 账号验证菜单可见性才有意义。", + "next": "用 permission.effective({account}) 看它实际能访问哪些菜单", + })) + } + + // ---------------------------------------------------------------- 低代码(P2-a) + + /// 读一条低代码功能定义(含三段 JSON)。 + /// + /// 🔴 三段 JSON 全是 TEXT:`f_form_data`(控件树)/ `f_tables_data`(表结构)/ + /// `f_column_data`(列表列)。读取时**不做任何规范化** —— 前端要的就是原文。 + async fn load_visualdev(&self, args: &Value) -> Result { + let id = args.get("id").and_then(Value::as_str).unwrap_or("").trim().to_string(); + let en_code = args + .get("enCode") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + if id.is_empty() && en_code.is_empty() { + return Err(ToolError::new( + "MISSING_ARG", + "id 与 enCode 至少给一个", + ) + .field("enCode") + .hint("enCode 比 id 好记(如 salesOrder);不知道就用 form.list 查") + .next("form.list", json!({}), "列出全部功能")); + } + + let rows = if !id.is_empty() { + let v = id.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_form_data,'') AS \"formData\", \ + COALESCE(f_tables_data,'') AS \"tablesData\", \ + COALESCE(f_column_data,'') AS \"columnData\" \ + FROM base_visual_dev WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&v], + ) + .await + .map_err(db_err)? + } else { + let v = en_code.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_form_data,'') AS \"formData\", \ + COALESCE(f_tables_data,'') AS \"tablesData\", \ + COALESCE(f_column_data,'') AS \"columnData\" \ + FROM base_visual_dev WHERE f_en_code = $1 AND f_delete_mark = 0 LIMIT 1", + &[&v], + ) + .await + .map_err(db_err)? + }; + + let Some(row) = rows.first() else { + let what = if id.is_empty() { &en_code } else { &id }; + return Err(ToolError::new( + "FORM_NOT_FOUND", + format!("低代码功能不存在或已删除: {what}"), + ) + .field(if id.is_empty() { "enCode" } else { "id" }) + .hint("base_visual_dev 里没有这条记录;确认是不是在别的应用(f_system_id)") + .next("form.list", json!({}), "列出全部功能")); + }; + + Ok(row.clone()) + } + + /// `form.list` —— 列低代码功能(不返回 JSON 正文,省 token)。 + async fn form_list(&self, args: &Value) -> Result { + let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); + + let mut params: Vec = Vec::new(); + let mut extra = String::new(); + if !keyword.is_empty() { + params.push(format!("%{keyword}%")); + let n = params.len(); + extra.push_str(&format!(" AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})")); + } + if let Some(t) = args.get("type").and_then(Value::as_i64) { + params.push(t.to_string()); + extra.push_str(&format!(" AND f_type = ${}::text::integer", params.len())); + } + if let Some(s) = args.get("state").and_then(Value::as_i64) { + params.push(s.to_string()); + extra.push_str(&format!(" AND f_state = ${}::text::integer", params.len())); + } + + let sql = format!( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_url_address,'') AS \"urlAddress\", \ + COALESCE(f_system_id,'') AS \"systemId\" \ + FROM base_visual_dev WHERE f_delete_mark = 0{extra} \ + ORDER BY f_sort_code, f_full_name LIMIT {limit}" + ); + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ + "count": rows.len(), + "forms": rows, + "note": "type: 1=在线开发 2=流程表单;state: 0=未发布 1=已发布。\ + 运行时读 base_visual_release(发布快照),改 dev 不发布看不到效果", + })) + } + + /// `form.describe` —— 把表单 JSON 解析成可读结构。 + async fn form_describe(&self, args: &Value) -> Result { + let inline = args + .get("formData") + .and_then(Value::as_str) + .map(str::to_string); + + // inline 模式:直接解析传入的 JSON,不查库 + if let Some(text) = inline { + let parsed: Value = serde_json::from_str(&text).map_err(|e| { + ToolError::new("BAD_JSON", format!("formData 不是合法 JSON: {e}")) + .field("formData") + })?; + let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; + return Ok(describe_json(&form, None, args)); + } + + let row = self.load_visualdev(args).await?; + let form_text = row["formData"].as_str().unwrap_or(""); + if form_text.trim().is_empty() { + return Err(ToolError::new( + "FORM_EMPTY", + format!("功能「{}」没有 f_form_data", row["fullName"].as_str().unwrap_or("")), + ) + .hint("可能是流程表单(type=2),它的 f_form_data 是字段映射数组而不是控件树")); + } + let parsed: Value = serde_json::from_str(form_text).map_err(|e| { + ToolError::new("BAD_JSON", format!("f_form_data 不是合法 JSON: {e}")) + })?; + let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; + Ok(describe_json(&form, Some(&row), args)) + } + + /// `form.validate` —— 表单与表结构的自洽性检查。 + async fn form_validate(&self, args: &Value) -> Result { + let inline_form = args.get("formData").and_then(Value::as_str); + let inline_tables = args.get("tablesData").and_then(Value::as_str); + + let (form_text, tables_text, source) = match (inline_form, inline_tables) { + (Some(f), Some(t)) => (f.to_string(), t.to_string(), "inline".to_string()), + (Some(_), None) => { + return Err(ToolError::new( + "MISSING_ARG", + "inline 模式必须同时给 formData 与 tablesData", + ) + .field("tablesData") + .hint("只有表单没有表结构,无法判断字段有没有对应列")); + } + _ => { + let row = self.load_visualdev(args).await?; + ( + row["formData"].as_str().unwrap_or("").to_string(), + row["tablesData"].as_str().unwrap_or("").to_string(), + row["id"].as_str().unwrap_or("").to_string(), + ) + } + }; + + if form_text.trim().is_empty() || tables_text.trim().is_empty() { + return Err(ToolError::new( + "FORM_INCOMPLETE", + "该功能缺少 f_form_data 或 f_tables_data,无法校验", + ) + .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); + } + + let fv: Value = serde_json::from_str(&form_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?; + let tv: Value = serde_json::from_str(&tables_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?; + + let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?; + let model = sspf_lowcode::ModelSchema::parse(&tv).map_err(|e| { + ToolError::new(e.code(), e.message()).field("tablesData") + })?; + + let report = sspf_lowcode::validate(&form, &model); + let mut out = report.to_json(); + out["source"] = json!(source); + out["summary"] = json!(format!( + "{} 个错误 / {} 个警告;{}", + report.error_count(), + report.warn_count(), + if report.ok() { + "设计稿自洽(注意:与真实数据库列的一致性未验)" + } else { + "设计稿不自洽,上动态 CRUD 前必须修" + } + )); + Ok(out) + } + + // ================================================================ + // 低代码动态 CRUD(P2-b) + // ================================================================ + + /// 🔴 加载低代码功能并解析出(表单, 模型)。 + /// + /// `id` / `enCode` 二选一 —— 与 `form.validate` 同一套加载逻辑。 + async fn load_lowcode( + &self, + args: &Value, + ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { + let row = self.load_visualdev(args).await?; + Self::lowcode_from_row(&row) + } + + /// 从 `base_visual_dev` 的一行解析出(表单, 模型)。 + fn lowcode_from_row( + row: &Value, + ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { + Self::lowcode_from_json( + row["formData"].as_str().unwrap_or(""), + row["tablesData"].as_str().unwrap_or(""), + ) + } + + /// 🔴 解析设计稿(`f_form_data` + `f_tables_data`)—— 库内行与内联入参共用。 + fn lowcode_from_json( + form_text: &str, + tables_text: &str, + ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { + let form_text = form_text.trim(); + let tables_text = tables_text.trim(); + + if form_text.is_empty() || tables_text.is_empty() { + return Err(ToolError::new( + "FORM_INCOMPLETE", + "该功能缺少 f_form_data 或 f_tables_data,无法动态 CRUD", + ) + .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); + } + + let fv: Value = serde_json::from_str(form_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?; + let tv: Value = serde_json::from_str(tables_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?; + + let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?; + let model = sspf_lowcode::ModelSchema::parse(&tv) + .map_err(|e| ToolError::new(e.code(), e.message()).field("tablesData"))?; + + Ok((form, model)) + } + + /// 🔴 取入参里的数据体(必须是对象)。 + fn record_payload(args: &Value) -> Result { + let data = args.get("data").cloned().unwrap_or_else(|| json!({})); + if !data.is_object() { + return Err(ToolError::new("BAD_ARG", "data 必须是对象").field("data")); + } + Ok(data) + } + + /// 🔴 `dryRun` 的默认值是 **true** —— 写工具先看再写。 + fn dry_run_flag(args: &Value) -> bool { + args.get("dryRun") + .and_then(Value::as_bool) + .unwrap_or(true) + } + + /// 把执行结果整理成工具输出。 + fn crud_json(outcome: &sspf_lowcode_exec::lowcode_crud::CrudOutcome) -> Value { + let statements: Vec = outcome + .sql + .iter() + .map(|s| { + json!({ + "kind": s.kind_str(), + "table": s.table, + "sql": s.text, + "params": s.params, + "columns": s.param_columns, + }) + }) + .collect(); + json!({ + "id": outcome.id, + "dryRun": outcome.dry_run, + "statements": outcome.statements, + "sql": statements, + "notes": outcome.notes, + }) + } + + /// `schema.table.create` —— 按设计稿建物理表,并回写 `f_tables_data`。 + /// + /// 两种模式: + /// + /// | 模式 | 入参 | 能落库吗 | + /// |---|---|---| + /// | 库内功能 | `id` / `enCode` | ✅(`dryRun=false` 时建表 + 回写) | + /// | 内联设计稿 | `formData` + `tablesData` | ❌ 只能演练(没有回写目标) | + /// + /// 🔴 内联模式的意义:设计稿还没入库时就能看到 DDL —— + /// 与 `form.validate` 的 inline 模式同款,也方便冒烟脚本钉住建表规则。 + async fn schema_table_create(&self, args: &Value) -> Result { + let dry_run = Self::dry_run_flag(args); + + let inline_form = args + .get("formData") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let inline_tables = args + .get("tablesData") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + // ---- 内联设计稿:只能演练 ---- + if !inline_form.is_empty() || !inline_tables.is_empty() { + if inline_form.is_empty() || inline_tables.is_empty() { + let missing = if inline_form.is_empty() { + "formData" + } else { + "tablesData" + }; + return Err(ToolError::new( + "MISSING_ARG", + "内联模式要同时给 formData 与 tablesData", + ) + .field(missing) + .hint( + "表单决定 logicalDelete / 主键策略,模型决定列 —— \ + 只给一半就建不出正确的表", + )); + } + if !dry_run { + return Err(ToolError::new( + "INLINE_REQUIRES_DRY_RUN", + "内联设计稿只能演练,不能落库", + ) + .field("dryRun") + .hint( + "落库要绑定一条功能记录(回写的目标)—— \ + 先把设计稿存进 base_visual_dev,再用 id / enCode 调", + )); + } + + let (form, model) = Self::lowcode_from_json(&inline_form, &inline_tables)?; + let outcome = + sspf_lowcode_exec::lowcode_ddl::create_tables(&self.state.db, &model, &form, true).await?; + return Ok(Self::ddl_json(None, &outcome)); + } + + // ---- 库内功能:建表 + 回写 ---- + let row = self.load_visualdev(args).await?; + let (form, model) = Self::lowcode_from_row(&row)?; + let visualdev_id = row["id"].as_str().unwrap_or("").to_string(); + + let outcome = sspf_lowcode_exec::lowcode_ddl::create_and_sync( + &self.state.db, + &visualdev_id, + &model, + &form, + dry_run, + ) + .await?; + + Ok(Self::ddl_json(Some(&visualdev_id), &outcome)) + } + + /// 把建表结果整理成工具输出。 + fn ddl_json( + visualdev_id: Option<&str>, + outcome: &sspf_lowcode_exec::lowcode_ddl::CreateTablesOutcome, + ) -> Value { + json!({ + "id": visualdev_id, + "dryRun": outcome.dry_run, + "tables": outcome.tables, + "skipped": outcome.skipped, + "statements": outcome.ddl.len(), + "ddl": outcome.ddl, + "model": outcome.model, + "notes": outcome.notes, + }) + } + + /// `data.record.insert` —— 按设计稿新增一条记录(主表 + 子表)。 + async fn data_record_insert(&self, args: &Value) -> Result { + let (form, model) = self.load_lowcode(args).await?; + let payload = Self::record_payload(args)?; + let dry_run = Self::dry_run_flag(args); + let now = sspf_lowcode_exec::lowcode_crud::now_iso(); + + // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), + // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 + let mut ctx = sspf_lowcode_exec::lowcode_crud::build_context( + None, + Some(sspf_lowcode_exec::lowcode_crud::DEFAULT_TENANT_ID), + Some(&now), + ); + + let outcome = sspf_lowcode_exec::lowcode_crud::insert_record( + &self.state.db, + &form, + &model, + &payload, + &mut ctx, + dry_run, + ) + .await?; + + Ok(Self::crud_json(&outcome)) + } + + /// `data.record.update` —— 按设计稿更新一条记录(子表走差集对账)。 + async fn data_record_update(&self, args: &Value) -> Result { + let (form, model) = self.load_lowcode(args).await?; + let payload = Self::record_payload(args)?; + let dry_run = Self::dry_run_flag(args); + let now = sspf_lowcode_exec::lowcode_crud::now_iso(); + + let record_id = args + .get("recordId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if record_id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "recordId 不能为空") + .field("recordId") + .hint("先用 data.query 查到记录的 id")); + } + + // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), + // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 + let mut ctx = sspf_lowcode_exec::lowcode_crud::build_context( + None, + Some(sspf_lowcode_exec::lowcode_crud::DEFAULT_TENANT_ID), + Some(&now), + ); + + let outcome = sspf_lowcode_exec::lowcode_crud::update_record( + &self.state.db, + &form, + &model, + &payload, + &mut ctx, + &record_id, + dry_run, + ) + .await?; + + Ok(Self::crud_json(&outcome)) + } + + /// `data.record.delete` —— 删一条记录(逻辑/物理按功能的 logicalDelete)。 + async fn data_record_delete(&self, args: &Value) -> Result { + let (form, model) = self.load_lowcode(args).await?; + let dry_run = Self::dry_run_flag(args); + let now = sspf_lowcode_exec::lowcode_crud::now_iso(); + + let record_id = args + .get("recordId") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if record_id.is_empty() { + return Err(ToolError::new("MISSING_ARG", "recordId 不能为空") + .field("recordId") + .hint("先用 data.query 查到记录的 id")); + } + + // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), + // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 + let mut ctx = sspf_lowcode_exec::lowcode_crud::build_context( + None, + Some(sspf_lowcode_exec::lowcode_crud::DEFAULT_TENANT_ID), + Some(&now), + ); + + let outcome = sspf_lowcode_exec::lowcode_crud::delete_record( + &self.state.db, + &form, + &model, + &mut ctx, + &record_id, + dry_run, + ) + .await?; + + Ok(Self::crud_json(&outcome)) + } +} + +/// 🔴 **不许经通用读工具投影/过滤的列**(口令与密钥)。 +/// +/// ## 为什么需要这一层 +/// +/// `data.query` / `data.count` 是「按表名读任意表」的通用口子。 +/// 不在这里挡,一句 `{"table":"base_user"}` 就能把全库口令哈希拖走 +/// (实测修复前确实返回了 `password` / `secretkey` 两列)。 +/// +/// ⇒ 三条约束: +/// 1. 缺省投影**滤掉**这些列; +/// 2. 显式 `columns` 要这些列 ⇒ `SENSITIVE_COLUMN`(不静默少给); +/// 3. `where` / `orderBy` 用它们 ⇒ 同样拒绝(否则成了「按哈希猜明文」的 oracle)。 +const SENSITIVE_COLUMNS: &[&str] = &["f_password", "f_secretkey"]; + +/// 是否敏感列(大小写不敏感 —— PG 会把标识符折叠成小写)。 +fn is_sensitive_column(name: &str) -> bool { + SENSITIVE_COLUMNS.iter().any(|c| c.eq_ignore_ascii_case(name)) +} + +/// 🔴 敏感列一律拒绝,并说清「为什么 + 去哪拿」。 +fn ensure_not_sensitive(name: &str, field: &'static str) -> Result<(), ToolError> { + if !is_sensitive_column(name) { + return Ok(()); + } + Err(ToolError::new( + "SENSITIVE_COLUMN", + format!("列 {name} 属于口令/密钥,不允许经通用读工具访问"), + ) + .field(field.to_string()) + .hint("口令列只存在于 base_user,任何工具都不投影它") + .next( + "permission.user.list", + json!({}), + "要看用户信息用这个(它本来就不返回口令字段)", + )) +} + +/// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。 +fn form_err(e: sspf_lowcode::FormError) -> ToolError { + ToolError::new(e.code(), e.message()) + .field("formData") + .hint("v4 表单的 f_form_data 是 `{formRef, fields:[…]}` 对象;\ + 流程表单是 `[{filedName,filedId,…}]` 数组 —— 后者不属于本引擎处理范围") +} + +/// 把解析结果组织成 `form.describe` 的输出。 +fn describe_json( + form: &sspf_lowcode::FormSchema, + row: Option<&Value>, + args: &Value, +) -> Value { + let main = form.main_fields(); + let subs = form.sub_tables(); + + let field_brief = |f: &sspf_lowcode::FieldNode| { + json!({ + "vModel": f.v_model, + "column": f.column_name(), + "label": f.label, + "jnpfKey": f.jnpf_key, + "widget": f.widget.as_str(), + "required": f.required, + "acceptsInput": f.widget.accepts_input(), + "visibility": f.visibility, + }) + }; + + let mut out = json!({ + "formRef": form.form_ref, + "formModel": form.form_model, + "labelPosition": form.label_position, + "labelWidth": form.label_width, + "primaryKeyPolicy": form.primary_key_policy, + "mainFields": main.iter().map(|f| field_brief(f)).collect::>(), + "subTables": subs.iter().map(|s| json!({ + "label": s.label, + "tableName": s.table_name, + "vModel": s.v_model, + "fields": s.children.iter() + .filter(|c| c.widget.occupies_column()) + .map(|c| field_brief(c)) + .collect::>(), + })).collect::>(), + "unknownWidgets": form.unknown_widgets().iter() + .map(|n| json!({"jnpfKey": n.jnpf_key, "label": n.label})) + .collect::>(), + "counts": { + "mainFields": main.len(), + "subTables": subs.len(), + }, + }); + + if let Some(r) = row { + out["id"] = r["id"].clone(); + out["fullName"] = r["fullName"].clone(); + out["enCode"] = r["enCode"].clone(); + out["type"] = r["type"].clone(); + out["state"] = r["state"].clone(); + } + + // 只有明确要求时才回原文(一张表单可能几十 KB) + if args.get("withRaw").and_then(Value::as_bool).unwrap_or(false) { + out["raw"] = form.raw.clone(); + } + + out +} + +/// 去重并保持稳定顺序(BTreeSet 排序,避免每次调用结果顺序漂移)。 +fn dedup(items: &[String]) -> Vec { + let set: std::collections::BTreeSet<&String> = items.iter().collect(); + set.into_iter().cloned().collect() +} + +/// 把 pglite 错误转成结构化的工具错误(AI 能看懂的那种)。 +fn db_err(e: pglite::Error) -> ToolError { + ToolError::new("DB_ERROR", format!("数据库错误: {e}")) + .hint("多数是 SQL 与当前 schema 不匹配;先 schema.table.list 确认表在不在") + .retryable() +} + +impl PlatformAdapter for NativeAdapter { + fn describe_env<'a>(&'a self) -> BoxFut<'a, EnvInfo> { + Box::pin(async move { + let system_id = self.main_system_id().await; + let tables = self.table_count().await; + + // 能力域 = 注册表里实际有工具的分类(不靠硬编码清单,避免「声称支持但没工具」) + let mut caps: Vec = sspf_mcp::Registry::global() + .all() + .iter() + .map(|t| t.category.as_str().to_string()) + .collect(); + caps.sort(); + caps.dedup(); + + EnvInfo { + backend: "native".to_string(), + version: env!("CARGO_PKG_VERSION").to_string(), + app_code: system_id.clone(), + system_id, + // 🔴 进程内适配器没有登录态:它本身就是管理员视角。 + user: None, + tables, + capabilities: caps, + } + }) + } + + fn invoke<'a>(&'a self, op: &'a str, args: Value) -> BoxFut<'a, Result> { + Box::pin(async move { + match op { + // ------------------------------------------------ 上下文 + "context.get" => { + let system_id = self.main_system_id().await; + let tables = self.table_count().await; + Ok(json!({ + "backend": "native", + "version": env!("CARGO_PKG_VERSION"), + "app_code": system_id, + "system_id": system_id, + "tables": tables, + })) + } + + // ------------------------------------------------ 表清单 + "schema.table.list" => { + let prefix = args + .get("prefix") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + + let rows = self + .state + .db + .query_json( + "SELECT t.table_name AS \"name\", \ + (SELECT count(*) FROM information_schema.columns c \ + WHERE c.table_schema = t.table_schema AND c.table_name = t.table_name)::int \ + AS \"columns\" \ + FROM information_schema.tables t \ + WHERE t.table_schema = 'public' AND t.table_type = 'BASE TABLE' \ + ORDER BY t.table_name", + ) + .await + .map_err(db_err)?; + + let filtered: Vec = rows + .into_iter() + .filter(|r| { + prefix.is_empty() + || r["name"].as_str().is_some_and(|n| n.starts_with(&prefix)) + }) + .collect(); + + Ok(json!({ + "count": filtered.len(), + "prefix": if prefix.is_empty() { Value::Null } else { json!(prefix) }, + "tables": filtered, + })) + } + + // ------------------------------------------------ 表结构 + "schema.table.describe" => { + let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); + // 🔴 表名只走白名单(`valid_table`),绝不拼接用户输入 + let Some(table) = valid_table(raw) else { + return Err(ToolError::new( + "INVALID_TABLE", + format!("表名不合法: {raw}"), + ) + .field("table") + .hint("只接受小写字母/数字/下划线,且必须以 f_ 或业务前缀开头") + .next( + "schema.table.list", + json!({}), + "先列出所有表,再挑一个", + )); + }; + + let rows = self + .state + .db + .query_json_params( + "SELECT column_name AS \"name\", \ + data_type AS \"type\", \ + is_nullable AS \"nullable\", \ + COALESCE(column_default, '') AS \"default\" \ + FROM information_schema.columns \ + WHERE table_schema = 'public' AND table_name = $1 \ + ORDER BY ordinal_position", + &[&table], + ) + .await + .map_err(db_err)?; + + if rows.is_empty() { + return Err(ToolError::new( + "TABLE_NOT_FOUND", + format!("表 {table} 不存在"), + ) + .field("table") + .next("schema.table.list", json!({}), "确认表名")); + } + + Ok(json!({ + "table": table, + "column_count": rows.len(), + "columns": rows, + })) + } + + // ------------------------------------------------ 菜单树 + "menu.tree" => { + let flat = args.get("flat").and_then(Value::as_bool).unwrap_or(false); + let system_id = self.main_system_id().await; + + let rows = self + .state + .db + .query_json_params( + "SELECT f_id AS \"id\", \ + f_parent_id AS \"parentId\", \ + f_full_name AS \"fullName\", \ + COALESCE(f_en_code, '') AS \"enCode\", \ + COALESCE(f_url_address, '') AS \"urlAddress\", \ + f_type AS \"type\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\" \ + FROM base_module \ + WHERE f_delete_mark = 0 AND f_system_id = $1 \ + ORDER BY f_sort_code, f_full_name", + &[&system_id], + ) + .await + .map_err(db_err)?; + + if flat { + return Ok(json!({ + "system_id": system_id, + "mode": "flat", + "count": rows.len(), + "menus": rows, + })); + } + + // 建树(父不存在的节点挂到根,避免脏数据导致整棵树消失) + let mut children: std::collections::BTreeMap> = + std::collections::BTreeMap::new(); + let mut ids = std::collections::HashSet::new(); + for r in &rows { + if let Some(id) = r["id"].as_str() { + ids.insert(id.to_string()); + } + } + for r in rows { + let parent = r["parentId"].as_str().unwrap_or("0").to_string(); + let key = if ids.contains(&parent) { parent } else { "0".to_string() }; + children.entry(key).or_default().push(r); + } + + /// 递归组装(深度上限防御脏数据造成环)。 + fn build( + parent: &str, + children: &std::collections::BTreeMap>, + depth: usize, + ) -> Vec { + if depth > 32 { + return Vec::new(); + } + let Some(nodes) = children.get(parent) else { + return Vec::new(); + }; + nodes + .iter() + .map(|n| { + let id = n["id"].as_str().unwrap_or("").to_string(); + let mut node = n.clone(); + node["children"] = Value::Array(build(&id, children, depth + 1)); + node + }) + .collect() + } + + let tree = build("0", &children, 0); + Ok(json!({ + "system_id": system_id, + "mode": "tree", + "count": ids.len(), + "menus": tree, + })) + } + + // ------------------------------------------------ 权限(只读) + "permission.role.list" => self.role_list(&args).await, + "permission.user.list" => self.user_list(&args).await, + "permission.authorize.list" => self.authorize_list(&args).await, + + // ------------------------------------------------ 字典(只读) + "dict.type.list" => self.dict_type_list(&args).await, + "dict.data.list" => self.dict_data_list(&args).await, + + // ------------------------------------------------ 数据(只读) + "data.query" => self.data_query(&args).await, + "data.count" => self.data_count(&args).await, + + // ------------------------------------------------ 索引 + "schema.index.list" => self.index_list(&args).await, + + // ------------------------------------------------ 写(第三批) + "menu.create" => self.menu_create(&args).await, + "menu.delete" => self.menu_delete(&args).await, + "dict.type.create" => self.dict_type_create(&args).await, + + // ------------------------------------------------ 授权(第四批) + "permission.authorize.grant" => self.authorize_grant(&args).await, + "permission.authorize.revoke" => self.authorize_revoke(&args).await, + "permission.effective" => self.permission_effective(&args).await, + "permission.user.create" => self.user_create(&args).await, + + // ------------------------------------------------ 低代码(P2-a,只读) + "form.list" => self.form_list(&args).await, + "form.describe" => self.form_describe(&args).await, + "form.validate" => self.form_validate(&args).await, + + // ------------------------------------------------ 低代码动态 CRUD(P2-b,写) + "schema.table.create" => self.schema_table_create(&args).await, + "data.record.insert" => self.data_record_insert(&args).await, + "data.record.update" => self.data_record_update(&args).await, + "data.record.delete" => self.data_record_delete(&args).await, + + // ------------------------------------------------ 流程(直调契约面 handler) + "workflow.template.list" => { + crate::mcp_compat::workflow_template_list(&self.state, args).await + } + "workflow.template.info" => { + crate::mcp_compat::workflow_template_info(&self.state, args).await + } + "workflow.template.create" => { + crate::mcp_compat::workflow_template_create(&self.state, args).await + } + "workflow.template.update" => { + crate::mcp_compat::workflow_template_update(&self.state, args).await + } + "workflow.template.delete" => { + crate::mcp_compat::workflow_template_delete(&self.state, args).await + } + "workflow.template.selector" => { + crate::mcp_compat::workflow_template_selector(&self.state, args).await + } + "workflow.task.list" => { + crate::mcp_compat::workflow_task_list(&self.state, args).await + } + + // ------------------------------------------------ 字典 / 菜单(写) + "dict.type.update" => crate::mcp_compat::dict_type_update(&self.state, args).await, + "dict.type.delete" => crate::mcp_compat::dict_type_delete(&self.state, args).await, + "dict.data.create" => crate::mcp_compat::dict_data_create(&self.state, args).await, + "menu.info" => crate::mcp_compat::menu_info(&self.state, args).await, + "menu.update" => crate::mcp_compat::menu_update(&self.state, args).await, + + // ------------------------------------------------ 权限(角色 / 用户) + "permission.role.create" => { + crate::mcp_compat::role_create(&self.state, args).await + } + "permission.role.delete" => { + crate::mcp_compat::role_delete(&self.state, args).await + } + "permission.user.delete" => { + crate::mcp_compat::user_delete(&self.state, args).await + } + + // ------------------------------------------------ 低代码表单(写 / 发布) + "form.create" => crate::mcp_compat::form_create(&self.state, args).await, + "form.update" => crate::mcp_compat::form_update(&self.state, args).await, + "form.delete" => crate::mcp_compat::form_delete(&self.state, args).await, + "form.release" => crate::mcp_compat::form_release(&self.state, args).await, + + // ------------------------------------------------ 应用 / 运维 + "context.app.list" => crate::mcp_compat::app_list(&self.state, args).await, + "permission.organize.tree" => { + crate::mcp_compat::organize_tree(&self.state, args).await + } + "form.selector" => crate::mcp_compat::form_selector(&self.state, args).await, + "ops.db.stats" => crate::mcp_compat::ops_db_stats(&self.state, args).await, + "ops.health" => crate::mcp_compat::ops_health(&self.state, args).await, + "ops.logs" => crate::mcp_compat::ops_logs(&self.state, args).await, + "ops.online" => crate::mcp_compat::ops_online(&self.state, args).await, + "ops.schedule.list" => { + crate::mcp_compat::ops_schedule_list(&self.state, args).await + } + + other => Err(ToolError::new( + "OP_NOT_IMPLEMENTED", + format!("原生适配器还没实现 op: {other}"), + ) + .hint("该工具已注册但后端未实现;先在 tools/mod.rs 里摘掉或补实现") + .next( + "sspf_discover", + json!({}), + "看看还有哪些工具可用", + )), + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 🔴 表名白名单必须挡住注入尝试 —— 这是 `schema.table.describe` 的唯一安全边界。 + #[test] + fn table_name_whitelist_blocks_injection() { + assert!(valid_table("data_resource").is_some()); + assert!(valid_table("base_user").is_some()); + assert!(valid_table("users; DROP TABLE base_user").is_none()); + assert!(valid_table("base_user--").is_none()); + assert!(valid_table("").is_none()); + } + + /// 🔴 口令/密钥列必须在通用读工具入口就被挡住。 + #[test] + fn sensitive_columns_are_blocked() { + assert!(is_sensitive_column("f_password")); + assert!(is_sensitive_column("F_PASSWORD"), "PG 折叠大小写,判断要不敏感"); + assert!(is_sensitive_column("f_secretkey")); + assert!(!is_sensitive_column("f_account")); + let e = ensure_not_sensitive("f_password", "columns").unwrap_err(); + assert_eq!(e.code, "SENSITIVE_COLUMN"); + assert!(!e.hints.is_empty(), "拒绝时要说清去哪拿用户信息"); + assert!(ensure_not_sensitive("f_account", "columns").is_ok()); + } + + /// 错误对象必须带 next_actions(AI 自纠的依据)。 + #[test] + fn db_error_carries_hint_and_is_retryable() { + // 构造一个 pglite 错误比较麻烦,这里只校验 ToolError 的形状约定 + let e = ToolError::new("DB_ERROR", "x").retryable().hint("y"); + assert!(e.retryable); + assert_eq!(e.hints.len(), 1); + } +} diff --git a/crates/sspf-mcp-adapter/src/mcp_compat.rs b/crates/sspf-mcp-adapter/src/mcp_compat.rs new file mode 100644 index 0000000..bb5457b --- /dev/null +++ b/crates/sspf-mcp-adapter/src/mcp_compat.rs @@ -0,0 +1,631 @@ +//! mcp_compat —— MCP 工具对**契约面 handler** 的进程内直调。 +//! +//! ## 为什么直调 handler,而不是重写一遍 SQL +//! +//! MCP 与 HTTP 是同一套能力的两个入口。若 MCP 自己拼 SQL,两边会**双份实现**: +//! 校验规则、默认值、软删语义、审计列都会各写一遍 ⇒ 必然漂移(dacli 踩过: +//! 50+ 处漂移修了 6 周)。这里直接调 `platform::compat::*` 的 handler +//! (与 HTTP 路由注册的是同一个函数),语义天然一致。 +//! +//! ## 身份从哪来 +//! +//! 进程内没有 HTTP 登录态。这里给 handler 造一套**管理员请求头**: +//! 用 `SessionStore::issue` 签发一个 `admin` 会话(与 HTTP 登录同一个表), +//! 再把 token 塞进 `Authorization`。`App-Code` 默认 `mainSystem`,可由工具入参覆盖。 +//! +//! 🔴 **等价于「本地 AI 就是管理员」** —— 与 `mcp_adapter.rs` 顶部的安全前提一致: +//! 该适配器只用于本地开发;对外暴露必须走 `BaselineHttpAdapter` 带真实 token。 +//! +//! ## 失败怎么报 +//! +//! handler 返回 `ActionResult{code,msg,data}`: +//! - `code=200` ⇒ 透传 `data`;`data` 为 null 时回 `{ok:true,msg}`(保留官方提示语) +//! - 其它 ⇒ `ToolError`(`BUSINESS_FAILED` / `NO_PERMISSION` / `NOT_LOGGED_IN`), +//! 带 `hints + next_actions`,让 AI 自己改参数而不是原样重试。 + +use std::collections::HashMap; +use std::sync::{Arc, Mutex, OnceLock}; + +use axum::body::Bytes; +use axum::extract::{Path, RawQuery, State}; +use axum::http::HeaderMap; +use serde_json::{json, Map, Value}; + +use sspf_mcp::adapter::ToolError; + +use sspf_core::envelope::ActionResult; +use sspf_core::state::AppState; + +/// handler 调用用的管理员头 —— **按 `SessionStore` 实例缓存**。 +/// +/// 🔴 不能用全局单例:测试里每个用例一个 `AppState`(各自一张 token 表), +/// 全局缓存的 token 在别的表里解析不出来 ⇒ 所有工具都 602。 +static ADMIN_HEADERS: OnceLock, HeaderMap)>>> = + OnceLock::new(); + +/// 管理员头缓存的**上界**。 +/// +/// 正常进程只有 1 个 `AppState`(1 条);测试里每个用例一个实例 ⇒ 不设界会随用例数增长。 +/// 满了直接清空(代价只是下次多签一个 token),**不做 LRU** —— 这里是缓存不是状态。 +const MAX_ADMIN_HEADER_CACHE: usize = 8; + +/// 造/复用管理员请求头,并按入参覆盖 `App-Code`。 +async fn headers(state: &AppState, args: &Value) -> HeaderMap { + let key = Arc::as_ptr(&state.sessions) as usize; + let cached = ADMIN_HEADERS + .get_or_init(|| Mutex::new(HashMap::new())) + .lock() + .ok() + .and_then(|m| m.get(&key).map(|(_, h)| h.clone())); + + let base = match cached { + Some(h) => h, + None => { + let mut h = HeaderMap::new(); + let admin_id = state + .db + .scalar_text("SELECT f_id FROM base_user WHERE f_account = 'admin' LIMIT 1") + .await + .ok() + .flatten() + .unwrap_or_default(); + let token = state.sessions.issue("admin", &admin_id, 1); + if let Ok(v) = token.parse() { + h.insert("authorization", v); + } + if let Ok(v) = "3".parse() { + h.insert("vue-version", v); + } + if let Ok(mut m) = ADMIN_HEADERS + .get_or_init(|| Mutex::new(HashMap::new())) + .lock() + { + if m.len() >= MAX_ADMIN_HEADER_CACHE { + m.clear(); + } + // 🔴 连同 Arc 一起存:地址可能被分配器复用,只存 headers 会让 + // 新 AppState 命中旧 token(测试里表现为随机 602)。 + m.insert(key, (Arc::clone(&state.sessions), h.clone())); + } + h + } + }; + + let mut h = base; + let app = args + .get("appCode") + .and_then(Value::as_str) + .unwrap_or("mainSystem"); + if let Ok(v) = app.parse() { + h.insert("app-code", v); + } + h +} + +/// 从入参挑出若干键,拼成 URL query(中文等字符会被正确百分号编码)。 +fn qs(args: &Value, keys: &[&str]) -> String { + let Some(obj) = args.as_object() else { + return String::new(); + }; + let mut pairs: Vec<(String, String)> = Vec::new(); + for k in keys { + let Some(v) = obj.get(*k) else { continue }; + if v.is_null() { + continue; + } + let s = match v { + Value::String(s) => s.clone(), + other => other.to_string(), + }; + if s.is_empty() { + continue; + } + pairs.push(((*k).to_string(), s)); + } + serde_urlencoded::to_string(&pairs).unwrap_or_default() +} + +/// 入参原样当 body(去掉 MCP 控制字段)。 +/// +/// 🔴 **`formData` / `columnData` / `tablesData` 这类列是 TEXT,但 handler 的 +/// `value_to_text()` 只接受 string/number/bool —— 传对象会被**静默丢弃**。** +/// ⇒ 这里统一把对象/数组序列化成 JSON 字符串,AI 可以直接写对象。 +fn body_of(args: &Value) -> Result { + let mut v = args.clone(); + if let Some(o) = v.as_object_mut() { + o.remove("dryRun"); + o.remove("appCode"); + for key in [ + "formData", + "columnData", + "tablesData", + "appColumnData", + "buttonData", + "appButtonData", + "interfaceParam", + ] { + let Some(slot) = o.get_mut(key) else { continue }; + if slot.is_object() || slot.is_array() { + let text = serde_json::to_string(slot).unwrap_or_default(); + *slot = Value::String(text); + } + } + } + if !v.is_object() { + return Err(ToolError::new("BAD_ARGS", "入参必须是 JSON 对象").field("args")); + } + serde_json::to_vec(&v) + .map(Bytes::from) + .map_err(|e| ToolError::new("BAD_ARGS", format!("序列化入参失败: {e}"))) +} + +/// 取必填字符串参数。 +fn need_str(args: &Value, key: &str) -> Result { + let s = args.get(key).and_then(Value::as_str).unwrap_or("").trim(); + if s.is_empty() { + return Err(ToolError::new("MISSING_ARG", format!("缺少必填参数 {key}")) + .field(key) + .hint("先 sspf_describe 看该工具的 input_schema") + .next("sspf_discover", json!({}), "先确认该用哪个工具")); + } + Ok(s.to_string()) +} + +/// 该域的「查证」工具 —— 业务失败时建议 AI 先列一下再改参数。 +fn next_tool_for(op: &str) -> Option<&'static str> { + if op.starts_with("workflow.") { + Some("workflow.template.list") + } else if op.starts_with("dict.") { + Some("dict.type.list") + } else if op.starts_with("menu.") { + Some("menu.tree") + } else if op.starts_with("permission.role.") { + Some("permission.role.list") + } else if op.starts_with("permission.user.") { + Some("permission.user.list") + } else if op.starts_with("form.") { + Some("form.list") + } else { + None + } +} + +/// `Json` ⇒ 工具结果 / 结构化错误。 +fn out(op: &str, resp: axum::Json) -> Result { + let a = resp.0; + if a.code == 200 { + return Ok(match a.data { + // 新建设备类端点常返裸 id 字符串(官方 `ActionResult.success(id)`)—— + // 包成 `{id}` 让 AI 拿到稳定字段,不用猜「这串是什么」。 + Value::String(s) => json!({ "id": s }), + Value::Null => json!({ "ok": true, "msg": a.msg }), + other => other, + }); + } + let code = match a.code { + 602 => "NOT_LOGGED_IN", + 403 => "NO_PERMISSION", + _ => "BUSINESS_FAILED", + }; + let mut err = ToolError::new(code, a.msg).hint("先 sspf_describe 看该工具的 pitfalls 与示例"); + if let Some(t) = next_tool_for(op) { + err = err.next(t, json!({}), "先列出现有数据,确认 id / enCode 是否正确"); + } + Err(err) +} + +// ================================================================ workflow + +pub async fn workflow_template_list(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &["keyword", "category", "type", "state", "currentPage", "pageSize"], + ))); + let r = sspf_compat_workflow::workflow::workflow_template_list( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("workflow.template.list", r) +} + +pub async fn workflow_template_info(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_workflow::workflow::workflow_template_info( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("workflow.template.info", r) +} + +pub async fn workflow_template_create(state: &AppState, args: Value) -> Result { + let body = body_of(&args)?; + let r = sspf_compat_workflow::workflow::workflow_template_create( + State(state.clone()), + headers(state, &args).await, + body, + ) + .await; + out("workflow.template.create", r) +} + +pub async fn workflow_template_update(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let body = body_of(&args)?; + let r = sspf_compat_workflow::workflow::workflow_template_update( + State(state.clone()), + headers(state, &args).await, + Path(id), + body, + ) + .await; + out("workflow.template.update", r) +} + +pub async fn workflow_template_delete(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_workflow::workflow::workflow_template_delete( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("workflow.template.delete", r) +} + +pub async fn workflow_task_list(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &["keyword", "type", "category", "currentPage", "pageSize"], + ))); + let r = sspf_compat_workflow::workflow::workflow_task_list( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("workflow.task.list", r) +} + +pub async fn workflow_template_selector(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &["keyword", "category", "type", "currentPage", "pageSize"], + ))); + let r = sspf_compat_workflow::workflow::workflow_template_selector( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("workflow.template.selector", r) +} + +// ================================================================ dict + +pub async fn dict_type_update(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let body = body_of(&args)?; + let r = sspf_compat_system::system::dict_type_update( + State(state.clone()), + headers(state, &args).await, + Path(id), + body, + ) + .await; + out("dict.type.update", r) +} + +pub async fn dict_type_delete(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_system::system::dict_type_delete( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("dict.type.delete", r) +} + +pub async fn dict_data_create(state: &AppState, args: Value) -> Result { + let body = body_of(&args)?; + let r = sspf_compat_system::system::dict_data_create( + State(state.clone()), + headers(state, &args).await, + body, + ) + .await; + out("dict.data.create", r) +} + +// ================================================================ menu + +pub async fn menu_info(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_system::system::menu_info( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("menu.info", r) +} + +pub async fn menu_update(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let body = body_of(&args)?; + let r = sspf_compat_system::system::menu_update( + State(state.clone()), + headers(state, &args).await, + Path(id), + body, + ) + .await; + out("menu.update", r) +} + +// ================================================================ permission + +pub async fn role_create(state: &AppState, args: Value) -> Result { + let body = body_of(&args)?; + let r = sspf_compat_permission::permission::role_create( + State(state.clone()), + headers(state, &args).await, + body, + ) + .await; + out("permission.role.create", r) +} + +pub async fn role_delete(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_permission::permission::role_delete( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("permission.role.delete", r) +} + +pub async fn user_delete(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_permission::permission::user_delete( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("permission.user.delete", r) +} + +// ================================================================ form + +pub async fn form_create(state: &AppState, args: Value) -> Result { + let body = body_of(&args)?; + let r = sspf_compat_online_dev::online_dev::visual_dev_create( + State(state.clone()), + headers(state, &args).await, + body, + ) + .await; + out("form.create", r) +} + +pub async fn form_update(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let body = body_of(&args)?; + let r = sspf_compat_online_dev::online_dev::visual_dev_update( + State(state.clone()), + headers(state, &args).await, + Path(id), + body, + ) + .await; + out("form.update", r) +} + +pub async fn form_delete(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_online_dev::online_dev::visual_dev_delete( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("form.delete", r) +} + +pub async fn form_release(state: &AppState, args: Value) -> Result { + let id = need_str(&args, "id")?; + let r = sspf_compat_online_dev::online_dev::visual_dev_release( + State(state.clone()), + headers(state, &args).await, + Path(id), + ) + .await; + out("form.release", r) +} + +// ================================================================ context / ops + +pub async fn app_list(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &["keyword", "type", "currentPage", "pageSize"], + ))); + let r = sspf_compat_system::system::system_list( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("context.app.list", r) +} + +pub async fn ops_logs(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &[ + "category", + "keyword", + "startTime", + "endTime", + "currentPage", + "pageSize", + ], + ))); + let r = sspf_compat_system::system::log_list( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("ops.logs", r) +} + +pub async fn ops_schedule_list(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &["keyword", "currentPage", "pageSize"], + ))); + let r = sspf_compat_system::scheduletask::task_list( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("ops.schedule.list", r) +} + +/// 健康检查:表数 / 会话数 / admin 是否在 —— 不走 HTTP,直接读库。 +pub async fn ops_health(state: &AppState, _args: Value) -> Result { + let tables = state + .db + .scalar_text( + "SELECT count(*)::text FROM information_schema.tables \ + WHERE table_schema = 'public' AND table_type = 'BASE TABLE'", + ) + .await + .ok() + .flatten() + .and_then(|s| s.parse::().ok()) + .unwrap_or(0); + let admin = state + .db + .scalar_text("SELECT f_account FROM base_user WHERE f_account = 'admin' LIMIT 1") + .await + .ok() + .flatten(); + let sessions = state.sessions.snapshot(); + Ok(json!({ + "backend": "native", + "version": env!("CARGO_PKG_VERSION"), + "tables": tables, + "adminSeeded": admin.is_some(), + "sessions": sessions.len(), + })) +} + +/// 在线会话:**按账号聚合**,不返回 token 本身(token 是凭据,不进工具输出)。 +pub async fn ops_online(state: &AppState, _args: Value) -> Result { + let snap = state.sessions.snapshot(); + let mut by_account: Map = Map::new(); + for (_, u) in snap { + let entry = by_account.entry(u.account.clone()).or_insert_with(|| { + json!({ + "account": u.account, + "isAdmin": u.is_admin == 1, + "sessions": 0, + "lastIssuedAtMs": 0, + "ips": Vec::::new(), + }) + }); + if let Some(o) = entry.as_object_mut() { + let n = o.get("sessions").and_then(Value::as_i64).unwrap_or(0) + 1; + o.insert("sessions".to_string(), json!(n)); + let last = o.get("lastIssuedAtMs").and_then(Value::as_i64).unwrap_or(0); + o.insert("lastIssuedAtMs".to_string(), json!(last.max(u.issued_at_ms))); + if !u.ip.is_empty() { + if let Some(arr) = o.get_mut("ips").and_then(Value::as_array_mut) { + if !arr.iter().any(|v| v.as_str() == Some(u.ip.as_str())) { + arr.push(json!(u.ip)); + } + } + } + } + } + Ok(json!({ + "online": by_account.len(), + "users": by_account.into_values().collect::>(), + })) +} + +// ================================================================ 机构树 / 表单下拉 / 库概览 + +pub async fn organize_tree(state: &AppState, args: Value) -> Result { + let r = sspf_compat_permission::permission::organize_list( + State(state.clone()), + headers(state, &args).await, + ) + .await; + out("permission.organize.tree", r) +} + +pub async fn form_selector(state: &AppState, args: Value) -> Result { + let raw = RawQuery(Some(qs( + &args, + &[ + "keyword", + "type", + "isRelease", + "webType", + "currentPage", + "pageSize", + ], + ))); + let r = sspf_compat_online_dev::online_dev::visual_dev_selector( + State(state.clone()), + headers(state, &args).await, + raw, + ) + .await; + out("form.selector", r) +} + +/// 库概览:关键表行数 + 数据库体积(排障时判断「空库 / 有数据 / 库太大」)。 +pub async fn ops_db_stats(state: &AppState, _args: Value) -> Result { + let mut counts = Map::new(); + for (label, table) in [ + ("users", "base_user"), + ("menus", "base_module"), + ("forms", "base_visual_dev"), + ("releasedForms", "base_visual_release"), + ("roles", "base_role"), + ("logs", "base_sys_log"), + ("workflowTemplates", "workflow_template"), + ] { + let n = state + .db + .scalar_text(&format!("SELECT count(*)::text FROM {table}")) + .await + .ok() + .flatten() + .and_then(|s| s.parse::().ok()) + .unwrap_or(-1); + counts.insert(label.to_string(), json!(n)); + } + let size = state + .db + .scalar_text("SELECT pg_database_size(current_database())::text") + .await + .ok() + .flatten(); + Ok(json!({ + "counts": counts, + "databaseBytes": size, + })) +} diff --git a/docs/CRATES-MIGRATION.md b/docs/CRATES-MIGRATION.md index 4ed0e76..cd361b2 100644 --- a/docs/CRATES-MIGRATION.md +++ b/docs/CRATES-MIGRATION.md @@ -484,16 +484,40 @@ ssw-platform/ - [x] `check-naming.sh` = 3 通过 / 0 失败 / 1 提示 - [x] `verify.sh --smoke` 14 步全绿(377.6s) -### 批次 M6 —— MCP 适配层下沉 +### 批次 M6 —— MCP 适配层下沉 ✅ 已完成 -**迁入**:`mcp_adapter.rs`(2,652 行)+ `mcp_compat.rs`(631 行) +**迁入**:`mcp_adapter.rs`(2,652 行)+ `mcp_compat.rs`(631 行)⇒ 共 3,283 行 -**新 crate**:`crates/sspf-mcp-adapter`(依赖 sspf-mcp + sspf-core + sspf-compat-*) +**新 crate**:`crates/sspf-mcp-adapter`(依赖 sspf-mcp + sspf-core + sspf-compat-{system,permission,workflow,online_dev} + sspf-lowcode + sspf-lowcode-exec + axum + pglite-rs) > 🔴 `mcp_compat.rs` 直调 `platform::compat::*` 的 handler ⇒ 它依赖**所有** compat 包。 > 这是唯一「知道全部包」的 crate ⇒ 它属于壳还是能力? > **决策**:放 `crates/`(它是「MCP 适配」这一项独立能力),但**放在最后一批**。 +**实际落地**: +- 壳侧 `src/backend/src/mcp_{adapter,compat}.rs` 变成转发壳(`pub use sspf_mcp_adapter::<模块>::*`) + ⇒ `main.rs` 的 `mcp_adapter::NativeAdapter::new(state)` 与 + `tests/mcp_tools_it.rs` 的 `use ssw_platform::mcp_adapter::NativeAdapter` **零改动**。 +- 跨 crate 路径改写:`crate::platform::…` → `sspf_core::…` / `sspf_compat_<域>::<域>::…`; + `crate::lowcode_{crud,ddl}::` → `sspf_lowcode_exec::lowcode_{crud,ddl}::`。 + 🔴 **只改路径前缀、模块名不变**(M5 的教训:`crate::lowcode_ddl` 不能改成 `crate::ddl`)。 + +**🔴 本批的一个发现(闸门暴露的既有问题)**: +把新 crate 纳入 CP1 扫描面后,CP1 立刻抓到 **5 处业务标识符泄漏** +(`permission.asset.dataResource` / `asset/DataResource` / `asset_data_resource`)—— +它们在 `mcp_adapter.rs` 的 **hint 提示语**与**单测断言**里,此前**不在扫描面内**所以一直隐形。 +⇒ 已全部改成**通用形态**(`permission.<模块>.<资源>` / `<模块>/<资源>` / `data_resource`)。 +**这正是「闸门必须与迁移同步改」的价值**:不扩扫描面 ⇒ 这 5 处会跟着代码搬进 crates 继续潜伏。 + +**出口判据**: +- [x] `cargo build --workspace` 零警告 +- [x] `cargo test --workspace` = 695 passed / 0 failed(与 M1 基线完全一致) +- [x] `check-arch.sh` = **19/19**(新增 AR14);`--self-test` = **9/9**(新增 AR14 反自证) +- [x] `check-boundary.sh` = **12/12**(CP1/CP2 纳入适配层 + 新增 **CP1'' 扫描面反自证**) +- [x] `check-contract.sh` = 10/10(反自证 12 例全过) +- [x] `check-module.sh` = 123/123;`check-citations.sh` = 4/4 +- [x] `check-naming.sh` = 3 通过 / 0 失败 / 1 提示 + ### 批次 M7 —— 收口:壳瘦身 + 闸门改造 - `src/backend/src/platform/` 只剩 re-export(如果 M2 决定保留旧路径) @@ -521,6 +545,7 @@ ssw-platform/ | 🆕 AR11 | — | ✅ `crates/sspf-compat-core`(底座)**不许**依赖其它契约面模块 + Cargo.toml 级判据 | | 🆕 AR12 | — | ✅ `crates/sspf-compat-*` 之间**不许**互相依赖(防环回流),白名单 3 条单向边 | | 🆕 AR13 | — | ✅ `crates/sspf-lowcode-exec` 依赖 ⊆ {lowcode, core, store, mcp, pglite-rs, chrono, serde_json} + 源码不许 `use sspf_pack_*` | +| 🆕 AR14 | — | ✅ `crates/sspf-mcp-adapter` 依赖 ⊆ {mcp, core, compat-*, lowcode*, axum, pglite-rs, serde*} + 源码不许 `use sspf_pack_*` | > 🔴 **AR11/AR12 的 Cargo.toml 级判据踩过 BSD grep 的坑**:`grep -E '^\s*...'` 在 macOS 上**永远匹配不到**(BSD grep 是 POSIX ERE,不认 `\s`)⇒ 尺子永远"通过"。 > 正确写法:`[[:space:]]`。**这个坑是 AR12 反自证第一次跑就失败暴露的** —— 没有反自证,就带着一把假尺子跑完了 M4。 diff --git a/docs/contract.md b/docs/contract.md index 77b5355..7c48346 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -3289,7 +3289,7 @@ perm-smoke-jnpf.sh 23 # 其余三个走「api 三导出(listX/saveX/deleteX)」3 条 + views 页面 1 条 + App.tsx 路由 1 条。 # (更早的 114 = 4 模块 × 28 + 2,那时本仓后端-only,前端 4×4 处全打 `⏭` 但仍计入条数。) check-module.sh 123 -check-boundary.sh 11 +check-boundary.sh 12 check-contract.sh 10 check-citations.sh 4 ``` diff --git a/docs/mcp.md b/docs/mcp.md index c36ae13..a72ac95 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -138,7 +138,7 @@ sspf_context # 1. 先确认环境 | ops | `ops.db.stats` | 关键表行数 + 库体积 | | **P3 这批(26 个)怎么实现的**:不重写 SQL,而是**进程内直调契约面 handler** -(`src/backend/src/mcp_compat.rs`),与 HTTP 路由注册的是同一个函数 ⇒ 校验、默认值、 +(`crates/sspf-mcp-adapter/src/mcp_compat.rs`),与 HTTP 路由注册的是同一个函数 ⇒ 校验、默认值、 软删语义只有一份。代价是 MCP 适配器必须构造管理员请求头(`SessionStore::issue` 一个 `admin` 会话),所以**它只适用于本地开发**;对外暴露要走 `BaselineHttpAdapter` 带真实 token。 @@ -352,7 +352,7 @@ PGLITE_DIR=/tmp/sspf-demo ./target/debug/ssw-platform --seed-lowcode-demo --dry- | 实现 | 位置 | 后端 | 用在哪 | |---|---|---|---| -| `NativeAdapter` | `src/backend/src/mcp_adapter.rs` | 进程内 `AppState` | 主力形态(`--mcp`) | +| `NativeAdapter` | `crates/sspf-mcp-adapter/src/mcp_adapter.rs` | 进程内 `AppState` | 主力形态(`--mcp`) | | `BaselineHttpAdapter` | `crates/sspf-adapter-baseline` | 远端 HTTP(Java 后端或本仓内核) | P4 影子对账 / 过渡期提速 | 基线适配器**刻意只映射 5 个只读 op**(`context.get` / `menu.tree` / @@ -444,7 +444,7 @@ cargo run -p sspf-adapter-baseline --example probe -- \ 1. 在 `crates/sspf-mcp/src/tools/mod.rs` 写一个 `ToolDef`: schema + 注解 + **五段自提示**(when_to_use / when_not_to_use / preconditions / pitfalls / examples) 2. 加进 `ALL_TOOLS` -3. 内核 `mcp_adapter.rs` 的 `invoke()` 加同名分支(`op` == `tool.id`,刻意同名) +3. 适配层 `mcp_adapter.rs` 的 `invoke()` 加同名分支(`op` == `tool.id`,刻意同名) 4. `cargo test -p sspf-mcp` —— 元测试会校验 schema 合法、`one_liner` ≤ 40 字、示例是合法 JSON、每个坑都有 `rationale` **协议层、元工具、注册表都不用改。** 这是分层加载的直接收益。 diff --git a/scripts/check-arch.sh b/scripts/check-arch.sh index b4793fc..d73b63c 100755 --- a/scripts/check-arch.sh +++ b/scripts/check-arch.sh @@ -41,6 +41,9 @@ # —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆 # MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存 # (近似检查:`static` + `Mutex/dev/null || true)" + if [ -z "$hits" ]; then + ok "AR14 适配层源码没有 use sspf_pack_*(业务知识没漏进适配层)" + else + bad "AR14 适配层源码出现了业务包引用(业务知识漏进适配层):" + printf '%s\n' "$hits" | sed 's/^/ /' + fi + fi +} + # ---------------------------------------------------------------- PACK1 # **spec 单一真源**:`modules/.rs` 只许做转发,不许自己写 spec。 # @@ -568,7 +620,7 @@ PY self_test() { local rc=0 - echo "── 反自证 1/8:造一个依赖越界的假 pack,AR2 必须报 ❌ ──" + echo "── 反自证 1/9:造一个依赖越界的假 pack,AR2 必须报 ❌ ──" local tmp="$ROOT/packs/__arch_selftest__" mkdir -p "$tmp" cat > "$tmp/Cargo.toml" <<'TOML' @@ -594,7 +646,7 @@ TOML rc=1 fi - echo "── 反自证 2/8:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──" + echo "── 反自证 2/9:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──" # # 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。 # 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。 @@ -632,7 +684,7 @@ TOML rc=1 fi - echo "── 反自证 3/8:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──" + echo "── 反自证 3/9:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──" # # 🔴 造在**临时模块文件**上(不动真文件):只要它同时有 `pub use sspf_pack_` # 和 `= EntitySpec {`,PACK1 就必须红。 @@ -658,7 +710,7 @@ RS echo "⏭ 跳过 PACK1 反自证(业务模块目录不存在)" fi - echo "── 反自证 4/8:往 sspf-plugin 塞 axum 依赖,AR8 必须报 ❌ ──" + echo "── 反自证 4/9:往 sspf-plugin 塞 axum 依赖,AR8 必须报 ❌ ──" local pfile="$CRATES/sspf-plugin/Cargo.toml" if [ -f "$pfile" ]; then cp "$pfile" "$pfile.bak" @@ -679,7 +731,7 @@ RS echo "⏭ 跳过 AR8 反自证(sspf-plugin 不存在)" fi - echo "── 反自证 5/8:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──" + echo "── 反自证 5/9:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──" # # 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。 # 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。 @@ -712,7 +764,7 @@ RS rc=1 fi - echo "── 反自证 6/8:往契约面底座塞 use super::system,AR11 必须报 ❌ ──" + echo "── 反自证 6/9:往契约面底座塞 use super::system,AR11 必须报 ❌ ──" # # 🔴 **M3 起底座有两处**:真源 `crates/sspf-compat-core/src/helper.rs`(实现) # + 转发壳 `src/backend/src/platform/compat/helper.rs`。**两处都注入、 @@ -739,7 +791,7 @@ RS rc=1 fi - echo "── 反自证 7/8:给域包塞一条未授权的跨包依赖,AR12 必须报 ❌ ──" + echo "── 反自证 7/9:给域包塞一条未授权的跨包依赖,AR12 必须报 ❌ ──" # # 🔴 **为什么必须自证 AR12**:它的判据是「读 Cargo.toml 找 sspf-compat-* 依赖」。 # 若 grep 模式写错(包名含连字符/下划线混用)⇒ 永远扫不到依赖 ⇒ @@ -766,7 +818,7 @@ RS rc=1 fi - echo "── 反自证 8/8:给执行层塞一个越界依赖 + 一条业务包引用,AR13 必须报 ❌ ──" + echo "── 反自证 8/9:给执行层塞一个越界依赖 + 一条业务包引用,AR13 必须报 ❌ ──" # # 🔴 **必须自证 AR13**:它的判据是「读 Cargo.toml + grep 源码」。 # 两种失效模式都得堵: @@ -799,6 +851,39 @@ RS rc=1 fi + echo "── 反自证 9/9:给适配层塞一个越界依赖 + 一条业务包引用,AR14 必须报 ❌ ──" + # + # 🔴 **必须自证 AR14**:它是 M6 新增的判据,守护的是「全仓唯一知道全部包的 + # 汇聚点」的依赖面。两种失效模式都得堵: + # ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(适配层拖进业务包 ⇒ 破 AR9 的隔离); + # ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(业务知识漏进适配层)。 + # 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。 + local a14ok=0 + local a14toml="$CRATES/sspf-mcp-adapter/Cargo.toml" + local a14src="$CRATES/sspf-mcp-adapter/src/__ar14_selftest.rs" + local a14need=0 a14c=0 a14out + if [ -f "$a14toml" ]; then + cp "$a14toml" "$a14toml.bak" + printf '\nsspf-contract = { path = "../sspf-contract" }\n' >> "$a14toml" + a14need=$((a14need+1)) + printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a14src" + a14need=$((a14need+1)) + a14out="$(check_ar14 2>&1 || true)" + [ -f "$a14toml.bak" ] && mv "$a14toml.bak" "$a14toml" + rm -f "$a14src" + # ① 越界依赖(sspf-contract)必须被依赖白名单抓到 + echo "$a14out" | grep -q "依赖越界" && a14c=$((a14c+1)) + # ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出") + echo "$a14out" | grep -q "sspf-mcp-adapter/src/__ar14_selftest" && a14c=$((a14c+1)) + [ "$a14need" -gt 0 ] && [ "$a14c" -ge "$a14need" ] && a14ok=1 + fi + if [ "$a14ok" -eq 1 ]; then + echo "✅ 反自证通过:AR14 抓到了越界依赖(sspf-contract)与适配层里的业务包引用" + else + echo "❌ 反自证失败:AR14 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的" + rc=1 + fi + return $rc } @@ -819,6 +904,7 @@ check_ar10 check_ar11 check_ar12 check_ar13 +check_ar14 check_pack1 check_mem1 check_mem2 diff --git a/scripts/check-boundary.sh b/scripts/check-boundary.sh index 8263615..7568100 100755 --- a/scripts/check-boundary.sh +++ b/scripts/check-boundary.sh @@ -53,6 +53,11 @@ done # 它也是「平台侧」(连库 / 跑 SQL / 校验),业务标识符泄漏同样要查。 # ⇒ 放进 CP1/CP2 的扫描范围(与契约面同款纪律)。 LOWCODE_EXEC="$ROOT/crates/sspf-lowcode-exec/src" +# 🔴 **M6 起 MCP 适配层真源在 `crates/sspf-mcp-adapter/src/`**—— +# 它也是「平台侧」(编排平台能力给 MCP 用),且它是**全仓唯一知道全部包的 +# 汇聚点** ⇒ 业务标识符泄漏 / 反向依赖业务层更要查。 +# ⇒ 放进 CP1/CP2 的扫描范围(与契约面、执行层同款纪律)。 +MCP_ADAPTER="$ROOT/crates/sspf-mcp-adapter/src" MODULES="$SRC/modules" MODULES_MOD="$MODULES/mod.rs" BOOTSTRAP="$SRC/bootstrap.rs" @@ -120,13 +125,55 @@ else no "扫描器自证失败:${SELFTEST_OUT}" fi +# ---- CP1'' 反自证:扫描面必须**真覆盖**新 crate(M6 新增目录)---- +# +# 🔴 **为什么必须有这一条**:CP1 的扫描面是**显式列出来的目录**(`PLATFORM_CORE` / +# `PLATFORM` / `COMPAT_DIRS` / `LOWCODE_EXEC` / `MCP_ADAPTER`)。 +# 代码搬到新 crate 后,若忘了把新目录加进扫描面 ⇒ 尺子**扫不到** ⇒ +# **永远"通过"** ⇒ 虚假安全感(AR9 自证注释里写明过这个坑)。 +# ⇒ 往新 crate 注入一个**业务表名**,必须被抓到 —— 抓不到 = 扫描面漏了。 +hdr "[CP1''] 扫描面反自证(往 M6 新 crate 注入业务表名 ⇒ 必须被抓到)" +if [ -d "${MCP_ADAPTER}" ]; then + CP1_PROBE="${MCP_ADAPTER}/__cp1_selftest.rs" + # 🔴 探针用**业务包真实声明的表名**(从业务层派生 ⇒ 探针本身不含硬编码清单)。 + CP1_PROBE_TOKEN="$(CP1_SCAN_PATH="${SCAN}" SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" - "${MODULES}" "${ROOT}/packs" <<'PYPROBE' +import os, re, sys +sys.path.insert(0, os.path.dirname(os.path.abspath(os.environ["CP1_SCAN_PATH"]))) +modules_dir, packs_dir = sys.argv[1], sys.argv[2] +spec = re.compile(r'table:\s*"([^"]+)"') +for src in [os.path.join(packs_dir, p, "src", "lib.rs") + for p in sorted(os.listdir(packs_dir)) if os.path.isdir(os.path.join(packs_dir, p))]: + if not os.path.isfile(src): + continue + m = spec.search(open(src, encoding="utf-8").read()) + if m: + print(m.group(1)) + break +PYPROBE +)" + if [ -n "${CP1_PROBE_TOKEN}" ]; then + printf 'const LEAK_PROBE: &str = "%s";\n' "${CP1_PROBE_TOKEN}" > "${CP1_PROBE}" + CP1_PROBE_OUT="$(SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" "${SCAN}" "${MODULES}" "${MCP_ADAPTER}" 2>&1 || true)" + rm -f "${CP1_PROBE}" + if printf '%s\n' "${CP1_PROBE_OUT}" | grep -q "${CP1_PROBE_TOKEN}"; then + ok "扫描面反自证通过:M6 新 crate(mcp-adapter)确实在 CP1 扫描面内(注入的 ${CP1_PROBE_TOKEN} 被抓到)" + else + no "扫描面反自证失败:往 mcp-adapter 注入 ${CP1_PROBE_TOKEN} 没被抓到 ⇒ 扫描面漏了新 crate(尺子已失效)" + fi + else + no "扫描面反自证失败:业务层没解析出业务表名(探针无法构造)" + fi +else + no "扫描面反自证失败:MCP_ADAPTER 目录不存在" +fi + # ---- CP1 平台层零业务标识符 ---- hdr "[CP1] 平台层零业务标识符(扫字符串字面量;禁止清单从业务层派生)" # 🔴 **业务层现在有两处**(批次 12 交付物 ②):`modules/*.rs`(面 A 内嵌) # + `packs/*/src/lib.rs`(业务包)⇒ 两处都要进「禁止清单」, # 否则包里的业务表名会从清单里消失 ⇒ 尺子变弱。 # 🔴 **M2 起平台层真源在 `crates/sspf-core/src/`** ⇒ 它必须进扫描面(否则扫空壳)。 -SCAN_OUT="$(SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" "${SCAN}" "${MODULES}" "${PLATFORM_CORE}" "${PLATFORM}" ${COMPAT_DIRS[@]+"${COMPAT_DIRS[@]}"} ${LOWCODE_EXEC:+"${LOWCODE_EXEC}"} "${SRC}/routes.rs" "${SRC}/main.rs" "${BOOTSTRAP}" 2>&1)" +SCAN_OUT="$(SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" "${SCAN}" "${MODULES}" "${PLATFORM_CORE}" "${PLATFORM}" ${COMPAT_DIRS[@]+"${COMPAT_DIRS[@]}"} ${LOWCODE_EXEC:+"${LOWCODE_EXEC}"} ${MCP_ADAPTER:+"${MCP_ADAPTER}"} "${SRC}/routes.rs" "${SRC}/main.rs" "${BOOTSTRAP}" 2>&1)" if [ "$?" -eq 0 ]; then ok "平台层没有业务标识符($(printf '%s\n' "${SCAN_OUT}" | tail -1))" else @@ -135,11 +182,12 @@ else fi # ---- CP2 平台层不反向依赖业务层 ---- -hdr "[CP2] 平台层不反向依赖业务层(sspf-core/** 与 compat 包/** 与 lowcode-exec/** 不许 use crate::modules)" -# 🔴 四处都扫:平台核心真源 + 平台转发壳 + 契约面 7 个包的真源 + 低代码执行层真源(M5)。 -CP2_HITS="$(grep -rn "use crate::modules" "${PLATFORM_CORE}" "${PLATFORM}" ${COMPAT_DIRS[@]+"${COMPAT_DIRS[@]}"} ${LOWCODE_EXEC:+"${LOWCODE_EXEC}"} 2>/dev/null)" +hdr "[CP2] 平台层不反向依赖业务层(sspf-core/** 与 compat 包/** 与 lowcode-exec/** 与 mcp-adapter/** 不许 use crate::modules)" +# 🔴 五处都扫:平台核心真源 + 平台转发壳 + 契约面 7 个包的真源 + 低代码执行层真源(M5) +# + MCP 适配层真源(M6)。 +CP2_HITS="$(grep -rn "use crate::modules" "${PLATFORM_CORE}" "${PLATFORM}" ${COMPAT_DIRS[@]+"${COMPAT_DIRS[@]}"} ${LOWCODE_EXEC:+"${LOWCODE_EXEC}"} ${MCP_ADAPTER:+"${MCP_ADAPTER}"} 2>/dev/null)" if [ -z "${CP2_HITS}" ]; then - ok "平台核心 / 转发壳 / 契约面各包 / 低代码执行层 都没有 use crate::modules" + ok "平台核心 / 转发壳 / 契约面各包 / 低代码执行层 / MCP 适配层 都没有 use crate::modules" else no "平台层引用了业务层:" printf '%s\n' "${CP2_HITS}" | sed 's/^/ /' diff --git a/src/backend/Cargo.toml b/src/backend/Cargo.toml index 1be99ac..cb31b0c 100644 --- a/src/backend/Cargo.toml +++ b/src/backend/Cargo.toml @@ -60,6 +60,9 @@ sspf-compat-online_dev = { path = "../../crates/sspf-compat-online_dev" } # MCP 工具层(元工具 + 分层加载)—— 内核实现它的 PlatformAdapter,反向依赖 sspf-mcp = { path = "../../crates/sspf-mcp" } +# 🔴 **MCP 适配层**(M6)—— 进程内直调 AppState 的 NativeAdapter + 契约面 handler 直调。 +# `src/backend/src/mcp_{adapter,compat}.rs` 现在只是转发壳 ⇒ `--mcp` 启动路径零感知。 +sspf-mcp-adapter = { path = "../../crates/sspf-mcp-adapter" } # 低代码元数据引擎(纯计算:解析/校验/SQL 生成) sspf-lowcode = { path = "../../crates/sspf-lowcode" } # 🔴 **低代码执行层**(M5)—— 连库 / 跑 SQL / 比对真实库列 / 事务 / 回写模型。 diff --git a/src/backend/src/mcp_adapter.rs b/src/backend/src/mcp_adapter.rs index f205246..396611b 100644 --- a/src/backend/src/mcp_adapter.rs +++ b/src/backend/src/mcp_adapter.rs @@ -1,2652 +1,5 @@ -//! mcp_adapter —— 内核侧实现 `sspf_mcp::PlatformAdapter`(**进程内直调**)。 -//! -//! ## 为什么放在内核里,而不是 sspf-mcp 里 -//! -//! 依赖方向是 `kernel → sspf-mcp → sspf-contract`(见 `PLAN.md` §3.2 AR5)。 -//! MCP 层不认识 `AppState`、不认识 `Db` —— 所以「怎么拿数据」只能由内核实现。 -//! -//! 好处是同一个 `sspf-mcp` 还能被 `BaselineHttpAdapter` 复用(P4 对账时打 Java 后端), -//! 两边的工具契约完全一致。 -//! -//! ## 为什么不走 HTTP 回环 -//! -//! `--mcp` 形态与 HTTP 形态**共用同一个 `AppState`**(同库、同连接、同会话表)。 -//! 走 HTTP 会多一层序列化 + 需要额外端口 + 需要先登录拿 token, -//! 而 AI 本地驱动开发时没有「登录」这个概念 —— 它就是这个进程的主人。 -//! -//! ## 🔴 但没有权限上下文 -//! -//! 进程内直调意味着**绕过登录与菜单守卫**。这在本地开发是特性(AI 就是管理员), -//! 在多用户部署是风险。⇒ 未来若把 MCP 暴露到网络,必须走 `BaselineHttpAdapter` -//! 带上真实 token,不能用本适配器。 +//! mcp_adapter —— **转发壳**:真源在 [`sspf_mcp_adapter::mcp_adapter`](M6 MCP 适配层下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M6。 -use std::collections::HashSet; - -use pglite::ToSql; -use serde_json::{json, Value}; - -use crate::platform::db::valid_table; -use crate::platform::state::AppState; - -use sspf_mcp::adapter::{BoxFut, EnvInfo, PlatformAdapter, ToolError}; - -/// 进程内适配器。 -pub struct NativeAdapter { - state: AppState, -} - -impl NativeAdapter { - /// 用装配好的状态构造。 - pub fn new(state: AppState) -> Self { - Self { state } - } - - /// 取主系统 id(`base_system.f_is_main=1`),查不到就回落常量。 - async fn main_system_id(&self) -> String { - self.state - .db - .scalar_text("SELECT f_id FROM base_system WHERE f_is_main = 1 LIMIT 1") - .await - .ok() - .flatten() - .unwrap_or_else(|| "mainSystem".to_string()) - } - - /// 数当前 schema 下的表(健康检查口径,与 `/api/health` 一致)。 - async fn table_count(&self) -> usize { - self.state - .db - .scalar_text( - "SELECT count(*)::text FROM information_schema.tables \ - WHERE table_schema = 'public' AND table_type = 'BASE TABLE'", - ) - .await - .ok() - .flatten() - .and_then(|s| s.parse().ok()) - .unwrap_or(0) - } - - /// 取一张表的全部列名(白名单来源)。 - /// - /// 🔴 这是 `data.query` / `data.count` 的**唯一安全边界**: - /// 表名、列名、排序字段都必须先在这里查到,才允许进 SQL。 - /// 参数化只能防「值注入」,防不了「结构注入」。 - async fn columns_of(&self, table: &str) -> Result, ToolError> { - let t = table.to_string(); - let rows = self - .state - .db - .query_json_params( - "SELECT column_name AS \"name\" FROM information_schema.columns \ - WHERE table_schema = 'public' AND table_name = $1 \ - ORDER BY ordinal_position", - &[&t], - ) - .await - .map_err(db_err)?; - - Ok(rows - .into_iter() - .filter_map(|r| r["name"].as_str().map(str::to_string)) - .collect()) - } - - /// 把结构化的 `where` 数组拼成 SQL 片段;**值全部进 `params`**,列名必须过白名单。 - /// - /// 占位符编号 = `params` 的长度(`$1` 起),所以调用方要先把前置参数 push 进去。 - fn build_where( - conds: &[Value], - allowed: &HashSet, - params: &mut Vec, - ) -> Result { - let mut clauses: Vec = Vec::new(); - - for c in conds { - let col = c.get("column").and_then(Value::as_str).unwrap_or(""); - if !allowed.contains(col) { - return Err(ToolError::new( - "UNKNOWN_COLUMN", - format!("列不存在: {col}"), - ) - .field("where.column") - .hint("先 schema.table.describe 确认列名(列名是 f_ 前缀)")); - } - let qcol = format!("\"{col}\""); - let op = c.get("op").and_then(Value::as_str).unwrap_or("eq"); - - match op { - "isnull" => clauses.push(format!("{qcol} IS NULL")), - "notnull" => clauses.push(format!("{qcol} IS NOT NULL")), - sym @ ("eq" | "ne" | "like" | "gt" | "ge" | "lt" | "le") => { - let mut v = c - .get("value") - .and_then(Value::as_str) - .unwrap_or("") - .to_string(); - if sym == "like" { - v = format!("%{v}%"); - } - params.push(v); - let n = params.len(); - let sql_op = match sym { - "eq" => "=", - "ne" => "<>", - "like" => "ILIKE", - "gt" => ">", - "ge" => ">=", - "lt" => "<", - _ => "<=", - }; - clauses.push(format!("{qcol} {sql_op} ${n}")); - } - other => { - return Err(ToolError::new( - "BAD_OPERATOR", - format!("不支持的比较符: {other}"), - ) - .field("where.op") - .hint("可用:eq / ne / like / gt / ge / lt / le / isnull / notnull")) - } - } - } - - Ok(if clauses.is_empty() { - String::new() - } else { - format!(" AND {}", clauses.join(" AND ")) - }) - } - - // ---------------------------------------------------------------- 权限 - - async fn role_list(&self, args: &Value) -> Result { - let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); - let enabled_only = args - .get("enabledOnly") - .and_then(Value::as_bool) - .unwrap_or(true); - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); - - let mut params: Vec = Vec::new(); - let mut extra = String::new(); - if !keyword.is_empty() { - params.push(format!("%{keyword}%")); - let n = params.len(); - extra.push_str(&format!( - " AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})" - )); - } - if enabled_only { - extra.push_str(" AND f_enabled_mark = 1"); - } - - let sql = format!( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ - f_type AS \"type\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\" \ - FROM base_role WHERE f_delete_mark = 0{extra} \ - ORDER BY f_sort_code, f_full_name LIMIT {limit}" - ); - - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - Ok(json!({ "count": rows.len(), "roles": rows })) - } - - async fn user_list(&self, args: &Value) -> Result { - let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); - let organize = args - .get("organizeId") - .and_then(Value::as_str) - .unwrap_or(""); - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); - - let mut params: Vec = Vec::new(); - let mut extra = String::new(); - if !keyword.is_empty() { - params.push(format!("%{keyword}%")); - let n = params.len(); - extra.push_str(&format!( - " AND (f_account ILIKE ${n} OR f_real_name ILIKE ${n} OR f_mobile_phone ILIKE ${n})" - )); - } - if !organize.is_empty() { - params.push(organize.to_string()); - let n = params.len(); - extra.push_str(&format!(" AND f_organize_id = ${n}")); - } - - // 🔴 绝不选 f_password / f_secretkey - let sql = format!( - "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \ - COALESCE(f_mobile_phone, '') AS \"mobilePhone\", \ - COALESCE(f_organize_id, '') AS \"organizeId\", \ - COALESCE(f_role_id, '') AS \"roleId\", \ - COALESCE(f_is_administrator, 0) AS \"isAdministrator\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - COALESCE(f_lock_mark, 0) AS \"lockMark\" \ - FROM base_user WHERE f_delete_mark = 0{extra} \ - ORDER BY f_account LIMIT {limit}" - ); - - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - Ok(json!({ "count": rows.len(), "users": rows })) - } - - async fn authorize_list(&self, args: &Value) -> Result { - let object_type = args - .get("objectType") - .and_then(Value::as_str) - .unwrap_or(""); - let object_id = args.get("objectId").and_then(Value::as_str).unwrap_or(""); - - if object_type.is_empty() || object_id.is_empty() { - return Err(ToolError::new( - "MISSING_ARG", - "objectType 与 objectId 都必填", - ) - .field("objectType") - .hint("先 permission.role.list 拿 roleId,或用 permission.user.list 拿 userId")); - } - - let (ot, oid) = (object_type.to_string(), object_id.to_string()); - let rows = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_item_type AS \"itemType\", f_item_id AS \"itemId\", \ - f_object_type AS \"objectType\", f_object_id AS \"objectId\" \ - FROM base_authorize \ - WHERE f_delete_mark = 0 AND f_object_type = $1 AND f_object_id = $2 \ - ORDER BY f_item_type, f_item_id", - &[&ot, &oid], - ) - .await - .map_err(db_err)?; - - // 只查了「直授」这一源,提示 AI 别忘了另外三源 - Ok(json!({ - "count": rows.len(), - "objectType": ot, - "objectId": oid, - "items": rows, - "note": "这里只有**直授**;实际权限是四源合并(直授 + 角色 + 组织 + 岗位),管理员短路", - })) - } - - // ---------------------------------------------------------------- 字典 - - async fn dict_type_list(&self, args: &Value) -> Result { - let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); - - let mut params: Vec = Vec::new(); - let mut extra = String::new(); - if !keyword.is_empty() { - params.push(format!("%{keyword}%")); - let n = params.len(); - extra.push_str(&format!( - " AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})" - )); - } - - // 🔴 `f_type` 是 **INTEGER**(官方 DDL)—— `COALESCE(f_type, '')` 会报 - // `invalid input syntax for type integer: ""`。默认值必须是 0 不是空串。 - let sql = format!( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ - COALESCE(f_type, 0) AS \"type\", COALESCE(f_is_tree, 0) AS \"isTree\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\" \ - FROM base_dictionary_type WHERE f_delete_mark = 0{extra} \ - ORDER BY f_sort_code, f_full_name LIMIT {limit}" - ); - - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - Ok(json!({ "count": rows.len(), "types": rows })) - } - - async fn dict_data_list(&self, args: &Value) -> Result { - let type_id = args - .get("dictionaryTypeId") - .and_then(Value::as_str) - .unwrap_or(""); - if type_id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "缺少 dictionaryTypeId") - .field("dictionaryTypeId") - .hint("先 dict.type.list 拿分类 id")); - } - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(100).clamp(1, 500); - - let tid = type_id.to_string(); - let sql = format!( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ - COALESCE(f_is_default, 0) AS \"isDefault\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\" \ - FROM base_dictionary_data \ - WHERE f_delete_mark = 0 AND f_dictionary_type_id = $1 \ - ORDER BY f_sort_code, f_full_name LIMIT {limit}" - ); - - let rows = self - .state - .db - .query_json_params(&sql, &[&tid]) - .await - .map_err(db_err)?; - - Ok(json!({ - "dictionaryTypeId": tid, - "count": rows.len(), - "items": rows, - })) - } - - // ---------------------------------------------------------------- 数据 - - async fn data_query(&self, args: &Value) -> Result { - let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); - let table = valid_table(raw).ok_or_else(|| { - ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")) - .field("table") - .hint("只接受小写字母/数字/下划线") - .next("schema.table.list", json!({}), "先列出所有表") - })?; - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(20).clamp(1, 200); - - let cols = self.columns_of(&table).await?; - if cols.is_empty() { - return Err(ToolError::new("TABLE_NOT_FOUND", format!("表 {table} 不存在")) - .field("table") - .next("schema.table.list", json!({}), "确认表名")); - } - - // 🔴 口令/密钥列**不许经通用读口子投影**(红线⑤)。 - // `data.query` 是「按表名读任意表」的通用口子:不挡这里, - // 一句 `{"table":"base_user"}` 就能把全库口令哈希拖走(实测会返回 password)。 - let readable: Vec = cols - .iter() - .filter(|c| !is_sensitive_column(c)) - .cloned() - .collect(); - let allowed: HashSet = readable.iter().cloned().collect(); - let n_hidden = cols.len() - readable.len(); - - // 选列:缺省全选(已滤掉敏感列);显式给了就逐个校验 - let select = match args.get("columns").and_then(Value::as_array) { - Some(arr) if !arr.is_empty() => { - let mut v = Vec::with_capacity(arr.len()); - for c in arr { - let name = c.as_str().unwrap_or(""); - ensure_not_sensitive(name, "columns")?; - if !allowed.contains(name) { - return Err(ToolError::new( - "UNKNOWN_COLUMN", - format!("列不存在: {name}"), - ) - .field("columns") - .hint("先 schema.table.describe 看列名")); - } - v.push(format!("\"{name}\"")); - } - v.join(", ") - } - _ => readable - .iter() - .map(|c| format!("\"{c}\"")) - .collect::>() - .join(", "), - }; - - // 条件 - let conds = args - .get("where") - .and_then(Value::as_array) - .cloned() - .unwrap_or_default(); - for c in &conds { - let col = c.get("column").and_then(Value::as_str).unwrap_or(""); - ensure_not_sensitive(col, "where.column")?; - } - let mut params: Vec = Vec::new(); - let where_sql = Self::build_where(&conds, &allowed, &mut params)?; - - // 排序(列名同样走白名单) - let order_sql = match args.get("orderBy").and_then(Value::as_str) { - Some(ob) if !ob.is_empty() => { - ensure_not_sensitive(ob, "orderBy")?; - if !allowed.contains(ob) { - return Err(ToolError::new("UNKNOWN_COLUMN", format!("排序列不存在: {ob}")) - .field("orderBy")); - } - let dir = if args.get("desc").and_then(Value::as_bool).unwrap_or(true) { - "DESC" - } else { - "ASC" - }; - format!(" ORDER BY \"{ob}\" {dir}") - } - _ => String::new(), - }; - - // table 已过 valid_table(仅 [a-z0-9_])⇒ 双引号包裹安全 - let sql = format!( - "SELECT {select} FROM \"{table}\" WHERE 1 = 1{where_sql}{order_sql} LIMIT {limit}" - ); - - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - Ok(json!({ - "table": table, - "count": rows.len(), - "limit": limit, - // 🔴 明说「藏着几列」—— 否则 AI 会以为这张表就这么多列 - "hiddenColumns": n_hidden, - "rows": rows, - })) - } - - async fn data_count(&self, args: &Value) -> Result { - let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); - let table = valid_table(raw).ok_or_else(|| { - ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")).field("table") - })?; - - let cols = self.columns_of(&table).await?; - if cols.is_empty() { - return Err(ToolError::new("TABLE_NOT_FOUND", format!("表 {table} 不存在")) - .field("table")); - } - let allowed: HashSet = cols.into_iter().collect(); - - let conds = args - .get("where") - .and_then(Value::as_array) - .cloned() - .unwrap_or_default(); - for c in &conds { - let col = c.get("column").and_then(Value::as_str).unwrap_or(""); - ensure_not_sensitive(col, "where.column")?; - } - let mut params: Vec = Vec::new(); - let where_sql = Self::build_where(&conds, &allowed, &mut params)?; - - let sql = format!("SELECT count(*)::text AS \"count\" FROM \"{table}\" WHERE 1 = 1{where_sql}"); - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - let count = rows - .first() - .and_then(|r| r["count"].as_str()) - .and_then(|s| s.parse::().ok()) - .unwrap_or(0); - - Ok(json!({ "table": table, "count": count })) - } - - // ---------------------------------------------------------------- 索引 - - async fn index_list(&self, args: &Value) -> Result { - let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); - let table = if raw.is_empty() { - None - } else { - Some(valid_table(raw).ok_or_else(|| { - ToolError::new("INVALID_TABLE", format!("表名不合法: {raw}")).field("table") - })?) - }; - - let rows = match &table { - Some(t) => { - let tt = t.clone(); - self.state - .db - .query_json_params( - "SELECT tablename AS \"table\", indexname AS \"name\", indexdef AS \"definition\" \ - FROM pg_indexes WHERE schemaname = 'public' AND tablename = $1 \ - ORDER BY indexname", - &[&tt], - ) - .await - } - None => { - self.state - .db - .query_json( - "SELECT tablename AS \"table\", indexname AS \"name\", indexdef AS \"definition\" \ - FROM pg_indexes WHERE schemaname = 'public' \ - ORDER BY tablename, indexname", - ) - .await - } - } - .map_err(db_err)?; - - Ok(json!({ "count": rows.len(), "indexes": rows })) - } - - // ---------------------------------------------------------------- 写:菜单 - - /// 解析 `App-Code` → `base_system.f_id`。 - async fn system_id_of(&self, code: &str) -> Result { - let c = code.to_string(); - let rows = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_system WHERE f_en_code = $1 LIMIT 1", - &[&c], - ) - .await - .map_err(db_err)?; - - rows.first() - .and_then(|r| r["id"].as_str()) - .map(str::to_string) - .ok_or_else(|| { - ToolError::new("SYSTEM_NOT_FOUND", format!("应用不存在: {code}")) - .field("systemEnCode") - .hint("主系统的 App-Code 是 `mainSystem`") - }) - } - - /// 建菜单 —— 写**完整 14 列**(含 `f_en_code` / `f_system_id`)。 - /// - /// 🔴 与 `sys.rs::module_save` 的差异见 `tools/write.rs` 顶部说明: - /// HTTP 侧那条只写 12 列,缺的两列正好是「面 B 权限判据」与「多应用隔离」。 - async fn menu_create(&self, args: &Value) -> Result { - let full_name = args - .get("fullName") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if full_name.is_empty() { - return Err(ToolError::new("MISSING_ARG", "fullName 不能为空").field("fullName")); - } - let en_code = args - .get("enCode") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if en_code.is_empty() { - return Err(ToolError::new("MISSING_ARG", "enCode 不能为空") - .field("enCode") - .hint("形如 permission.<模块>.<资源>,如 permission.asset.dataResource")); - } - if !en_code.contains('.') { - return Err(ToolError::new( - "BAD_EN_CODE", - format!("enCode 必须带域前缀: {en_code}"), - ) - .field("enCode") - .hint("形如 permission.asset.dataResource")); - } - - let url = args - .get("urlAddress") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if url.is_empty() { - return Err(ToolError::new("MISSING_ARG", "urlAddress 不能为空").field("urlAddress")); - } - if url.starts_with('/') { - return Err(ToolError::new( - "BAD_URL_ADDRESS", - format!("urlAddress 不要前导斜杠: {url}"), - ) - .field("urlAddress") - .hint("写 `asset/DataResource`,不是 `/asset/DataResource`")); - } - if !url - .chars() - .all(|c| c.is_ascii_alphanumeric() || matches!(c, '/' | '_' | '-')) - { - return Err(ToolError::new("BAD_URL_ADDRESS", "urlAddress 只能含字母数字与 / _ -") - .field("urlAddress")); - } - - let parent_id = args - .get("parentId") - .and_then(Value::as_str) - .unwrap_or("0") - .to_string(); - let menu_type = args.get("type").and_then(Value::as_i64).unwrap_or(2); - if !matches!(menu_type, 1 | 2) { - return Err(ToolError::new("BAD_TYPE", "type 只能是 1(目录)或 2(页面)") - .field("type")); - } - let icon = args.get("icon").and_then(Value::as_str).map(str::to_string); - let sort_code = args.get("sortCode").and_then(Value::as_i64).unwrap_or(0); - let sys_code = args - .get("systemEnCode") - .and_then(Value::as_str) - .unwrap_or("mainSystem") - .to_string(); - - let system_id = self.system_id_of(&sys_code).await?; - - // 父菜单必须存在(除根) - if parent_id != "0" { - let pid = parent_id.clone(); - let hit = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[&pid], - ) - .await - .map_err(db_err)?; - if hit.is_empty() { - return Err(ToolError::new( - "PARENT_NOT_FOUND", - format!("父菜单不存在: {parent_id}"), - ) - .field("parentId") - .next("menu.tree", json!({"flat": true}), "先看现有菜单 id")); - } - } - - // 🔴 en_code / url_address 在官方 DDL 里**没有 UNIQUE** ⇒ 必须应用层查重 - let dup = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_full_name AS \"name\", \ - COALESCE(f_en_code, '') AS \"enCode\", \ - COALESCE(f_url_address, '') AS \"urlAddress\" \ - FROM base_module \ - WHERE f_delete_mark = 0 AND f_system_id = $1 \ - AND (f_en_code = $2 OR f_url_address = $3) LIMIT 1", - &[&system_id, &en_code, &url], - ) - .await - .map_err(db_err)?; - if let Some(row) = dup.first() { - let same_code = row["enCode"].as_str() == Some(en_code.as_str()); - return Err(ToolError::new( - "MENU_EXISTS", - format!( - "{} 已存在:{}(id={})", - if same_code { "enCode" } else { "urlAddress" }, - row["name"].as_str().unwrap_or(""), - row["id"].as_str().unwrap_or("") - ), - ) - .field(if same_code { "enCode" } else { "urlAddress" }) - .hint("换一个编码/路径,或先删掉旧菜单(menu.delete)") - .next("menu.tree", json!({"flat": true}), "确认是不是同一个菜单")); - } - - let id = crate::platform::ids::new_uuid(); - let vals: Vec> = vec![ - Some(id.clone()), - Some("0".to_string()), // f_tenant_id:本期单租户 - Some(full_name.clone()), - Some(en_code.clone()), - Some(url.clone()), - Some(parent_id.clone()), - Some(menu_type.to_string()), - None, // f_category:VARCHAR 分类,缺省 NULL - icon, - Some(sort_code.to_string()), - Some("1".to_string()), // f_enabled_mark - Some("0".to_string()), // f_delete_mark - Some(system_id.clone()), - ]; - let refs: Vec<&(dyn ToSql + Sync)> = - vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); - - // 🔴 `now()` 直接写进 SQL(不占参数位,避免 `$n` 序号错位) - self.state - .db - .exec_params( - "INSERT INTO base_module \ - (f_id, f_tenant_id, f_full_name, f_en_code, f_url_address, f_parent_id, \ - f_type, f_category, f_icon, f_sort_code, f_enabled_mark, f_delete_mark, \ - f_system_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ - $7::text::integer, $8::text, $9::text, $10::text::bigint, \ - $11::text::integer, $12::text::integer, $13::text, now())", - &refs, - ) - .await - .map_err(db_err)?; - - Ok(json!({ - "id": id, - "fullName": full_name, - "enCode": en_code, - "urlAddress": url, - "systemId": system_id, - "next": "菜单已建,但**非管理员还看不到** —— 需要给角色授权(base_authorize)", - })) - } - - /// 软删菜单(只置 `f_delete_mark`,不动物理行)。 - async fn menu_delete(&self, args: &Value) -> Result { - let id = args.get("id").and_then(Value::as_str).unwrap_or("").trim(); - if id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "id 不能为空") - .field("id") - .next("menu.tree", json!({"flat": true}), "先查菜单 id")); - } - let mid = id.to_string(); - - let hit = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_full_name AS \"name\" FROM base_module \ - WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[&mid], - ) - .await - .map_err(db_err)?; - let Some(row) = hit.first() else { - return Err(ToolError::new("MENU_NOT_FOUND", format!("菜单不存在或已删除: {id}")) - .field("id") - .next("menu.tree", json!({"flat": true}), "确认 id")); - }; - let name = row["name"].as_str().unwrap_or("").to_string(); - - self.state - .db - .exec_params( - "UPDATE base_module SET f_delete_mark = 1, f_delete_time = now() \ - WHERE f_id = $1 AND f_delete_mark = 0", - &[&mid], - ) - .await - .map_err(db_err)?; - - Ok(json!({ - "deleted": true, - "id": mid, - "fullName": name, - "note": "软删:物理行还在(迁移靠 --data-only,物理删会丢历史)。子菜单不级联。", - })) - } - - // ---------------------------------------------------------------- 写:字典 - - async fn dict_type_create(&self, args: &Value) -> Result { - let full_name = args - .get("fullName") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - let en_code = args - .get("enCode") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if full_name.is_empty() || en_code.is_empty() { - return Err(ToolError::new("MISSING_ARG", "fullName 与 enCode 都必填") - .field("fullName")); - } - if !en_code - .chars() - .all(|c| c.is_ascii_alphanumeric() || c == '_') - { - return Err(ToolError::new( - "BAD_EN_CODE", - format!("enCode 只能含小写字母/数字/下划线: {en_code}"), - ) - .field("enCode") - .hint("用 `order_status` 这种,不要中文或连字符")); - } - - let dict_type = args.get("type").and_then(Value::as_i64).unwrap_or(1); - let is_tree = if args.get("isTree").and_then(Value::as_bool).unwrap_or(false) { - 1i64 - } else { - 0i64 - }; - let parent_id = args - .get("parentId") - .and_then(Value::as_str) - .unwrap_or("0") - .to_string(); - let sort_code = args.get("sortCode").and_then(Value::as_i64).unwrap_or(0); - - // en_code 查重(同表内) - let ec = en_code.clone(); - let dup = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_dictionary_type \ - WHERE f_delete_mark = 0 AND f_en_code = $1 LIMIT 1", - &[&ec], - ) - .await - .map_err(db_err)?; - if let Some(row) = dup.first() { - return Err(ToolError::new( - "DICT_EXISTS", - format!("字典编码已存在: {en_code}(id={})", row["id"].as_str().unwrap_or("")), - ) - .field("enCode") - .next("dict.type.list", json!({"keyword": en_code}), "确认是否同一个")); - } - - let id = crate::platform::ids::new_uuid(); - let vals: Vec> = vec![ - Some(id.clone()), - Some("0".to_string()), - Some(parent_id), - Some(full_name.clone()), - Some(en_code.clone()), - Some(is_tree.to_string()), - Some(dict_type.to_string()), - None, // f_description - Some("1".to_string()), // f_enabled_mark - Some(sort_code.to_string()), - Some("0".to_string()), // f_delete_mark - ]; - let refs: Vec<&(dyn ToSql + Sync)> = - vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); - - self.state - .db - .exec_params( - "INSERT INTO base_dictionary_type \ - (f_id, f_tenant_id, f_parent_id, f_full_name, f_en_code, f_is_tree, f_type, \ - f_description, f_enabled_mark, f_sort_code, f_delete_mark, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, \ - $6::text::integer, $7::text::integer, $8::text, \ - $9::text::integer, $10::text::bigint, $11::text::integer, now())", - &refs, - ) - .await - .map_err(db_err)?; - - Ok(json!({ - "id": id, - "fullName": full_name, - "enCode": en_code, - "note": "分类已建;字典**项**(下拉选项)P2 通过 dict.data.create 补", - })) - } - - // ---------------------------------------------------------------- 授权(第四批:闭环) - - /// `base_authorize.f_object_type` → 真实表名。 - /// - /// 🔴 **硬编码映射,不走 `valid_table`**:这里的表名是代码常量, - /// 用户输入只贡献 enum 值,拼不出任意表名 —— 这是比字符串白名单更强的保证。 - fn object_table(object_type: &str) -> Option<&'static str> { - match object_type { - "user" => Some("base_user"), - "role" => Some("base_role"), - "organize" => Some("base_organize"), - "position" => Some("base_position"), - _ => None, - } - } - - /// 解析要授权的菜单:`menuId` 优先,否则 `menuEnCode` + 应用过滤。 - /// - /// 返回 `(id, fullName, enCode)`。 - async fn resolve_menu(&self, args: &Value) -> Result<(String, String, String), ToolError> { - let menu_id = args - .get("menuId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - let menu_en_code = args - .get("menuEnCode") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - - if menu_id.is_empty() && menu_en_code.is_empty() { - return Err(ToolError::new( - "MISSING_ARG", - "menuId 与 menuEnCode 至少给一个", - ) - .field("menuId") - .hint("menuId 来自 menu.tree;menuEnCode 是建菜单时写的 permission.x.y") - .next("menu.tree", json!({"flat": true}), "先查菜单 id 与编码")); - } - - let rows = if !menu_id.is_empty() { - let mid = menu_id.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_en_code,'') AS \"enCode\" \ - FROM base_module WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[&mid], - ) - .await - .map_err(db_err)? - } else { - // 按编码查时要限定应用:不同应用可以存在同 en_code 的菜单,跨应用授权等于授错对象。 - let sys_code = args - .get("systemEnCode") - .and_then(Value::as_str) - .unwrap_or("mainSystem") - .to_string(); - let system_id = self.system_id_of(&sys_code).await?; - let ec = menu_en_code.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_en_code,'') AS \"enCode\" \ - FROM base_module \ - WHERE f_en_code = $1 AND f_system_id = $2 AND f_delete_mark = 0 LIMIT 1", - &[&ec, &system_id], - ) - .await - .map_err(db_err)? - }; - - let Some(row) = rows.first() else { - let what = if menu_id.is_empty() { - format!("enCode={menu_en_code}(应用 {})", args - .get("systemEnCode") - .and_then(Value::as_str) - .unwrap_or("mainSystem")) - } else { - format!("id={menu_id}") - }; - return Err(ToolError::new("MENU_NOT_FOUND", format!("菜单不存在或已删除: {what}")) - .field(if menu_id.is_empty() { "menuEnCode" } else { "menuId" }) - .hint("P0:同 enCode 在不同应用是不同菜单,确认 systemEnCode 对不对") - .next("menu.tree", json!({"flat": true}), "列出当前应用的菜单")); - }; - - Ok(( - row["id"].as_str().unwrap_or("").to_string(), - row["fullName"].as_str().unwrap_or("").to_string(), - row["enCode"].as_str().unwrap_or("").to_string(), - )) - } - - /// `permission.authorize.grant` —— 幂等:已授权则原样返回,不重复插行。 - async fn authorize_grant(&self, args: &Value) -> Result { - let object_type = args - .get("objectType") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - let Some(table) = Self::object_table(&object_type) else { - return Err(ToolError::new( - "BAD_OBJECT_TYPE", - format!("objectType 只能是 user / role / organize / position,收到 `{object_type}`"), - ) - .field("objectType") - .hint("推荐 role(一改全组生效);user 只用于临时特批,逐人维护成本高")); - }; - - let object_id = args - .get("objectId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if object_id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "objectId 不能为空") - .field("objectId") - .hint(format!( - "用主键 id,不是账号/名称(permission.{} 拿)", - if object_type == "user" { "user" } else { "role" }.to_string() - + ".list" - ))); - } - - // 授权对象必须真实存在:插一条指向不存在 id 的行,不报错但永远不生效。 - let obj_rows = self - .state - .db - .query_json_params( - &format!( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"name\" \ - FROM {table} WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1" - ), - &[&object_id], - ) - .await - .map_err(db_err)?; - if obj_rows.is_empty() { - return Err(ToolError::new( - "OBJECT_NOT_FOUND", - format!("{object_type} 不存在或已删除: {object_id}"), - ) - .field("objectId") - .hint("objectId 是主键,不是账号/角色名") - .next( - format!("permission.{}.list", if object_type == "user" { "user" } else { "role" }), - json!({}), - "先列表拿真实 id", - )); - } - let object_name = obj_rows[0]["name"].as_str().unwrap_or("").to_string(); - - let (menu_id, menu_name, menu_en_code) = self.resolve_menu(args).await?; - - // 幂等:已有未删的同三元组 ⇒ 直接返回,不插重复行。 - let dup = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_authorize \ - WHERE f_item_type = 'module' AND f_item_id = $1 \ - AND f_object_type = $2 AND f_object_id = $3 AND f_delete_mark = 0 LIMIT 1", - &[&menu_id, &object_type, &object_id], - ) - .await - .map_err(db_err)?; - if let Some(row) = dup.first() { - return Ok(json!({ - "granted": false, - "alreadyGranted": true, - "authorizeId": row["id"].as_str().unwrap_or(""), - "objectType": object_type, - "objectId": object_id, - "menuId": menu_id, - "note": "该授权已存在(幂等,未重复插入)", - })); - } - - let id = crate::platform::ids::new_uuid(); - let vals: Vec> = vec![ - Some(id.clone()), - Some("0".to_string()), // f_tenant_id - Some("module".to_string()), // f_item_type - Some(menu_id.clone()), - Some(object_type.clone()), - Some(object_id.clone()), - Some("0".to_string()), // f_sort_code - Some("0".to_string()), // f_delete_mark - ]; - let refs: Vec<&(dyn ToSql + Sync)> = - vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); - - self.state - .db - .exec_params( - "INSERT INTO base_authorize \ - (f_id, f_tenant_id, f_item_type, f_item_id, f_object_type, f_object_id, \ - f_sort_code, f_delete_mark, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ - $7::text::bigint, $8::text::integer, now())", - &refs, - ) - .await - .map_err(db_err)?; - - Ok(json!({ - "granted": true, - "authorizeId": id, - "objectType": object_type, - "objectId": object_id, - "objectName": object_name, - "menuId": menu_id, - "menuName": menu_name, - "menuEnCode": menu_en_code, - "next": "用 permission.effective 复核是否真的生效(四源并集 ∩ 当前应用)", - })) - } - - /// `permission.authorize.revoke` —— 软删;撤不存在的行要报错(不静默成功)。 - async fn authorize_revoke(&self, args: &Value) -> Result { - let object_type = args - .get("objectType") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if Self::object_table(&object_type).is_none() { - return Err(ToolError::new( - "BAD_OBJECT_TYPE", - format!("objectType 只能是 user / role / organize / position,收到 `{object_type}`"), - ) - .field("objectType")); - } - let object_id = args - .get("objectId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if object_id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "objectId 不能为空").field("objectId")); - } - - let (menu_id, menu_name, _) = self.resolve_menu(args).await?; - - let hit = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_authorize \ - WHERE f_item_type = 'module' AND f_item_id = $1 \ - AND f_object_type = $2 AND f_object_id = $3 AND f_delete_mark = 0 LIMIT 1", - &[&menu_id, &object_type, &object_id], - ) - .await - .map_err(db_err)?; - let Some(row) = hit.first() else { - // 🔴 不静默成功:撤一条不存在的授权,最常见原因是 objectId 用错了(账号 vs id)。 - return Err(ToolError::new( - "AUTHORIZE_NOT_FOUND", - format!("没有这条授权:{object_type}={object_id} → {menu_name}"), - ) - .field("objectId") - .hint("objectId 是主键;用 permission.authorize.list 确认这条授权到底存不存在")); - }; - let auth_id = row["id"].as_str().unwrap_or("").to_string(); - - self.state - .db - .exec_params( - "UPDATE base_authorize SET f_delete_mark = 1, f_delete_time = now() \ - WHERE f_id = $1 AND f_delete_mark = 0", - &[&auth_id], - ) - .await - .map_err(db_err)?; - - Ok(json!({ - "revoked": true, - "authorizeId": auth_id, - "objectType": object_type, - "objectId": object_id, - "menuId": menu_id, - "menuName": menu_name, - "note": "只撤这一源;用户仍可能通过角色/组织/岗位拿到同一菜单 ⇒ 用 permission.effective 复核", - })) - } - - /// 查某个对象(user/role/…)被直授的菜单 id 列表。 - async fn authorized_modules( - &self, - object_type: &str, - object_id: &str, - ) -> Result, ToolError> { - let rows = self - .state - .db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_item_type = 'module' AND f_object_type = $1 AND f_object_id = $2 \ - AND f_delete_mark = 0", - &[&object_type, &object_id], - ) - .await - .map_err(db_err)?; - Ok(rows - .iter() - .filter_map(|r| r["itemId"].as_str().map(str::to_string)) - .filter(|s| !s.is_empty()) - .collect()) - } - - /// `permission.effective` —— 四源并集 + 按应用过滤,两组数都给。 - /// - /// 🔴 这是「授权了但看不见」的唯一诊断入口:能把「没授上」和 - /// 「授上了但不在这个应用」区分开,省掉反复 grep 数据库。 - async fn permission_effective(&self, args: &Value) -> Result { - let user_id = args - .get("userId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - let account = args - .get("account") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - - if user_id.is_empty() && account.is_empty() { - return Err(ToolError::new( - "MISSING_ARG", - "userId 与 account 至少给一个", - ) - .field("userId") - .hint("userId 是主键;不知道 id 就传 account,工具内部换算") - .next("permission.user.list", json!({}), "列出用户拿 id")); - } - - // 解析用户(id 优先) - let user_rows = if !user_id.is_empty() { - let uid = user_id.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_account,'') AS \"account\", \ - COALESCE(f_is_administrator, 0) AS \"isAdmin\" \ - FROM base_user WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[&uid], - ) - .await - .map_err(db_err)? - } else { - let acc = account.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_account,'') AS \"account\", \ - COALESCE(f_is_administrator, 0) AS \"isAdmin\" \ - FROM base_user WHERE f_account = $1 AND f_delete_mark = 0 LIMIT 1", - &[&acc], - ) - .await - .map_err(db_err)? - }; - let Some(urow) = user_rows.first() else { - return Err(ToolError::new( - "USER_NOT_FOUND", - format!( - "用户不存在: {}", - if user_id.is_empty() { &account } else { &user_id } - ), - ) - .field(if user_id.is_empty() { "account" } else { "userId" }) - .next("permission.user.list", json!({}), "列出用户确认账号")); - }; - let uid = urow["id"].as_str().unwrap_or("").to_string(); - let uaccount = urow["account"].as_str().unwrap_or("").to_string(); - let is_admin = urow["isAdmin"].as_i64().unwrap_or(0) == 1; - - let sys_code = args - .get("systemEnCode") - .and_then(Value::as_str) - .unwrap_or("mainSystem") - .to_string(); - let system_id = self.system_id_of(&sys_code).await?; - let with_detail = args - .get("withMenuDetail") - .and_then(Value::as_bool) - .unwrap_or(false); - - // ---- 四源各自收集(保留来源,才能回答「这条权限从哪来」)---- - let direct = self.authorized_modules("user", &uid).await?; - - let role_ids: Vec = { - let u = uid.clone(); - self.state - .db - .query_json_params( - "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1", - &[&u], - ) - .await - .map_err(db_err)? - .iter() - .filter_map(|r| r["roleId"].as_str().map(str::to_string)) - .filter(|s| !s.is_empty()) - .collect() - }; - let mut from_roles: Vec = Vec::new(); - for rid in &role_ids { - from_roles.extend(self.authorized_modules("role", rid).await?); - } - - let relation_ids = |object_type: &'static str| { - let u = uid.clone(); - let ot = object_type.to_string(); - let db = self.state.db.clone(); - async move { - db.query_json_params( - "SELECT f_object_id AS \"objectId\" FROM base_user_relation \ - WHERE f_user_id = $1 AND f_object_type = $2", - &[&u, &ot], - ) - .await - .map(|rows| { - rows.iter() - .filter_map(|r| r["objectId"].as_str().map(str::to_string)) - .filter(|s| !s.is_empty()) - .collect::>() - }) - } - }; - - let organize_ids: Vec = relation_ids("organize").await.map_err(db_err)?; - let mut from_orgs: Vec = Vec::new(); - for oid in &organize_ids { - from_orgs.extend(self.authorized_modules("organize", oid).await?); - } - - let position_ids: Vec = relation_ids("position").await.map_err(db_err)?; - let mut from_positions: Vec = Vec::new(); - for pid in &position_ids { - from_positions.extend(self.authorized_modules("position", pid).await?); - } - - // ---- 并集(去重)---- - use std::collections::BTreeSet; - let mut union: BTreeSet = BTreeSet::new(); - for group in [&direct, &from_roles, &from_orgs, &from_positions] { - union.extend(group.iter().cloned()); - } - - // ---- 当前应用内的菜单(按 system_id 过滤 + 未软删)---- - let sys = system_id.clone(); - let sys_menus = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_url_address,'') AS \"urlAddress\", \ - COALESCE(f_en_code,'') AS \"enCode\" \ - FROM base_module WHERE f_system_id = $1 AND f_delete_mark = 0", - &[&sys], - ) - .await - .map_err(db_err)?; - - let sys_ids: BTreeSet = sys_menus - .iter() - .filter_map(|r| r["id"].as_str().map(str::to_string)) - .collect(); - - if is_admin { - // 管理员短路:守卫直接放行,不看授权表。 - let mut menus: Vec = sys_menus; - if !with_detail { - menus = menus - .iter() - .map(|m| json!(m["id"].as_str().unwrap_or(""))) - .collect(); - } - return Ok(json!({ - "userId": uid, - "account": uaccount, - "isAdmin": true, - "systemId": system_id, - "mode": "admin-bypass", - "visible": { "count": sys_ids.len(), "menus": menus }, - "note": "管理员短路:守卫在第一条判据就返回 true,与 base_authorize 无关", - })); - } - - let visible_ids: BTreeSet = union.intersection(&sys_ids).cloned().collect(); - - let visible_menus: Vec = if with_detail { - sys_menus - .iter() - .filter(|m| { - m["id"] - .as_str() - .is_some_and(|id| visible_ids.contains(id)) - }) - .cloned() - .collect() - } else { - visible_ids.iter().map(|id| json!(id)).collect() - }; - - Ok(json!({ - "userId": uid, - "account": uaccount, - "isAdmin": false, - "systemId": system_id, - "sources": { - "direct": { "objectIds": [], "menuIds": direct }, - "role": { "objectIds": role_ids, "menuIds": dedup(&from_roles) }, - "organize": { "objectIds": organize_ids, "menuIds": dedup(&from_orgs) }, - "position": { "objectIds": position_ids, "menuIds": dedup(&from_positions) }, - }, - "fourSource": { "count": union.len(), "menuIds": union.iter().cloned().collect::>() }, - "visible": { "count": visible_ids.len(), "menus": visible_menus }, - "explain": "fourSource 是四源并集(授权表不带应用维度);visible 再与当前应用的菜单求交。\ - 两者不一致说明有授权指向了别的应用的菜单(或菜单已删)。", - })) - } - - /// `permission.user.create` —— 建普通用户(可同时绑角色)。 - /// - /// 🔴 存在的唯一理由:**验证授权闭环必须有一个非管理员账号**。 - /// 管理员走 `is_admin` 短路,永远看得见,用 admin 测菜单可见性等于没测。 - /// - /// 🔴 刻意不开放建管理员:`isAdministrator` 被硬编码为 0, - /// 入参只接受 false。让 AI 顺手造超管是难以回收的权限风险。 - async fn user_create(&self, args: &Value) -> Result { - let account = args - .get("account") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if account.is_empty() { - return Err(ToolError::new("MISSING_ARG", "account 不能为空").field("account")); - } - if account.len() > 50 - || !account - .chars() - .next() - .is_some_and(|c| c.is_ascii_alphabetic()) - || !account - .chars() - .all(|c| c.is_ascii_alphanumeric() || c == '_') - { - return Err(ToolError::new( - "BAD_ACCOUNT", - format!("account 只能字母开头 + 字母数字下划线,且 ≤50 字符: {account}"), - ) - .field("account") - .hint("如 zhangsan、li_si01")); - } - - let real_name = args - .get("realName") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if real_name.is_empty() { - return Err(ToolError::new("MISSING_ARG", "realName 不能为空").field("realName")); - } - - let password = args - .get("password") - .and_then(Value::as_str) - .unwrap_or("") - .to_string(); - if password.len() < 6 { - return Err(ToolError::new("BAD_PASSWORD", "password 至少 6 位") - .field("password") - .hint("传**明文**,工具内部算 md5 存库;传 md5 会导致登录永远失败")); - } - - // 🔴 软删的账号也算占用:否则「删了重建」会让历史授权指向新 id, - // 出现「新建的人莫名其妙有一堆权限」。 - let dup = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_delete_mark,0) AS \"deleted\" \ - FROM base_user WHERE f_account = $1 LIMIT 1", - &[&account], - ) - .await - .map_err(db_err)?; - if let Some(row) = dup.first() { - let deleted = row["deleted"].as_i64().unwrap_or(0) == 1; - return Err(ToolError::new( - "ACCOUNT_EXISTS", - format!( - "账号已存在{}: {account}", - if deleted { "(已软删,仍占用)" } else { "" } - ), - ) - .field("account") - .hint(if deleted { - "软删的账号仍占用编码;换一个账号,或在库里恢复原账号" - } else { - "换一个账号" - }) - .next("permission.user.list", json!({"keyword": account}), "先确认是不是同一个人")); - } - - // 角色必须存在(绑到不存在的角色 = 一条永远不生效的关系行) - let role_ids: Vec = args - .get("roleIds") - .and_then(Value::as_array) - .map(|a| { - a.iter() - .filter_map(Value::as_str) - .map(|s| s.trim().to_string()) - .filter(|s| !s.is_empty()) - .collect() - }) - .unwrap_or_default(); - for rid in &role_ids { - let r = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[rid], - ) - .await - .map_err(db_err)?; - if r.is_empty() { - return Err(ToolError::new( - "ROLE_NOT_FOUND", - format!("角色不存在: {rid}"), - ) - .field("roleIds") - .hint("roleIds 是角色主键(如 role_user),不是角色名") - .next("permission.role.list", json!({}), "列出角色拿真实 id")); - } - } - - let gender = args - .get("gender") - .and_then(Value::as_str) - .unwrap_or("unknown") - .to_string(); - let mobile = args - .get("mobilePhone") - .and_then(Value::as_str) - .map(str::to_string); - let email = args - .get("email") - .and_then(Value::as_str) - .map(str::to_string); - - let id = crate::platform::ids::new_uuid(); - let pwd_md5 = crate::platform::cipher::md5_hex(&password); - - let vals: Vec> = vec![ - Some(id.clone()), - Some("0".to_string()), // f_tenant_id - Some(account.clone()), - Some(real_name.clone()), - Some(gender), - mobile, - email, - Some(pwd_md5), - Some("0".to_string()), // f_is_administrator —— 硬编码,不开放 - Some("1".to_string()), // f_enabled_mark - Some("0".to_string()), // f_delete_mark - Some("0".to_string()), // f_sort_code - ]; - let refs: Vec<&(dyn ToSql + Sync)> = - vals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); - - self.state - .db - .exec_params( - "INSERT INTO base_user \ - (f_id, f_tenant_id, f_account, f_real_name, f_gender, f_mobile_phone, f_email, \ - f_password, f_is_administrator, f_enabled_mark, f_delete_mark, f_sort_code, \ - f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, $7::text, \ - $8::text, $9::text::integer, $10::text::integer, $11::text::integer, \ - $12::text::bigint, now())", - &refs, - ) - .await - .map_err(db_err)?; - - // 绑角色(base_role_relation:用户标识在 f_object_id,不在 f_user_id) - for rid in &role_ids { - let rel_id = crate::platform::ids::new_uuid(); - let rvals: Vec> = vec![ - Some(rel_id), - Some("0".to_string()), // f_tenant_id - Some(rid.clone()), // f_role_id - Some("user".to_string()), // f_object_type - Some(id.clone()), // f_object_id - Some("0".to_string()), // f_sort_code - Some("0".to_string()), // f_delete_mark - ]; - let rrefs: Vec<&(dyn ToSql + Sync)> = - rvals.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); - self.state - .db - .exec_params( - "INSERT INTO base_role_relation \ - (f_id, f_tenant_id, f_role_id, f_object_type, f_object_id, \ - f_sort_code, f_delete_mark, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, \ - $6::text::bigint, $7::text::integer, now())", - &rrefs, - ) - .await - .map_err(db_err)?; - } - - Ok(json!({ - "id": id, - "account": account, - "realName": real_name, - "isAdministrator": false, - "roleIds": role_ids, - "note": "口令已转 md5 存库,明文不落地。用 non-admin 账号验证菜单可见性才有意义。", - "next": "用 permission.effective({account}) 看它实际能访问哪些菜单", - })) - } - - // ---------------------------------------------------------------- 低代码(P2-a) - - /// 读一条低代码功能定义(含三段 JSON)。 - /// - /// 🔴 三段 JSON 全是 TEXT:`f_form_data`(控件树)/ `f_tables_data`(表结构)/ - /// `f_column_data`(列表列)。读取时**不做任何规范化** —— 前端要的就是原文。 - async fn load_visualdev(&self, args: &Value) -> Result { - let id = args.get("id").and_then(Value::as_str).unwrap_or("").trim().to_string(); - let en_code = args - .get("enCode") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - - if id.is_empty() && en_code.is_empty() { - return Err(ToolError::new( - "MISSING_ARG", - "id 与 enCode 至少给一个", - ) - .field("enCode") - .hint("enCode 比 id 好记(如 salesOrder);不知道就用 form.list 查") - .next("form.list", json!({}), "列出全部功能")); - } - - let rows = if !id.is_empty() { - let v = id.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_en_code,'') AS \"enCode\", \ - COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ - COALESCE(f_form_data,'') AS \"formData\", \ - COALESCE(f_tables_data,'') AS \"tablesData\", \ - COALESCE(f_column_data,'') AS \"columnData\" \ - FROM base_visual_dev WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", - &[&v], - ) - .await - .map_err(db_err)? - } else { - let v = en_code.clone(); - self.state - .db - .query_json_params( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_en_code,'') AS \"enCode\", \ - COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ - COALESCE(f_form_data,'') AS \"formData\", \ - COALESCE(f_tables_data,'') AS \"tablesData\", \ - COALESCE(f_column_data,'') AS \"columnData\" \ - FROM base_visual_dev WHERE f_en_code = $1 AND f_delete_mark = 0 LIMIT 1", - &[&v], - ) - .await - .map_err(db_err)? - }; - - let Some(row) = rows.first() else { - let what = if id.is_empty() { &en_code } else { &id }; - return Err(ToolError::new( - "FORM_NOT_FOUND", - format!("低代码功能不存在或已删除: {what}"), - ) - .field(if id.is_empty() { "enCode" } else { "id" }) - .hint("base_visual_dev 里没有这条记录;确认是不是在别的应用(f_system_id)") - .next("form.list", json!({}), "列出全部功能")); - }; - - Ok(row.clone()) - } - - /// `form.list` —— 列低代码功能(不返回 JSON 正文,省 token)。 - async fn form_list(&self, args: &Value) -> Result { - let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); - let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); - - let mut params: Vec = Vec::new(); - let mut extra = String::new(); - if !keyword.is_empty() { - params.push(format!("%{keyword}%")); - let n = params.len(); - extra.push_str(&format!(" AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})")); - } - if let Some(t) = args.get("type").and_then(Value::as_i64) { - params.push(t.to_string()); - extra.push_str(&format!(" AND f_type = ${}::text::integer", params.len())); - } - if let Some(s) = args.get("state").and_then(Value::as_i64) { - params.push(s.to_string()); - extra.push_str(&format!(" AND f_state = ${}::text::integer", params.len())); - } - - let sql = format!( - "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ - COALESCE(f_en_code,'') AS \"enCode\", \ - COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ - COALESCE(f_url_address,'') AS \"urlAddress\", \ - COALESCE(f_system_id,'') AS \"systemId\" \ - FROM base_visual_dev WHERE f_delete_mark = 0{extra} \ - ORDER BY f_sort_code, f_full_name LIMIT {limit}" - ); - let refs: Vec<&(dyn ToSql + Sync)> = - params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); - let rows = self - .state - .db - .query_json_params(&sql, &refs) - .await - .map_err(db_err)?; - - Ok(json!({ - "count": rows.len(), - "forms": rows, - "note": "type: 1=在线开发 2=流程表单;state: 0=未发布 1=已发布。\ - 运行时读 base_visual_release(发布快照),改 dev 不发布看不到效果", - })) - } - - /// `form.describe` —— 把表单 JSON 解析成可读结构。 - async fn form_describe(&self, args: &Value) -> Result { - let inline = args - .get("formData") - .and_then(Value::as_str) - .map(str::to_string); - - // inline 模式:直接解析传入的 JSON,不查库 - if let Some(text) = inline { - let parsed: Value = serde_json::from_str(&text).map_err(|e| { - ToolError::new("BAD_JSON", format!("formData 不是合法 JSON: {e}")) - .field("formData") - })?; - let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; - return Ok(describe_json(&form, None, args)); - } - - let row = self.load_visualdev(args).await?; - let form_text = row["formData"].as_str().unwrap_or(""); - if form_text.trim().is_empty() { - return Err(ToolError::new( - "FORM_EMPTY", - format!("功能「{}」没有 f_form_data", row["fullName"].as_str().unwrap_or("")), - ) - .hint("可能是流程表单(type=2),它的 f_form_data 是字段映射数组而不是控件树")); - } - let parsed: Value = serde_json::from_str(form_text).map_err(|e| { - ToolError::new("BAD_JSON", format!("f_form_data 不是合法 JSON: {e}")) - })?; - let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; - Ok(describe_json(&form, Some(&row), args)) - } - - /// `form.validate` —— 表单与表结构的自洽性检查。 - async fn form_validate(&self, args: &Value) -> Result { - let inline_form = args.get("formData").and_then(Value::as_str); - let inline_tables = args.get("tablesData").and_then(Value::as_str); - - let (form_text, tables_text, source) = match (inline_form, inline_tables) { - (Some(f), Some(t)) => (f.to_string(), t.to_string(), "inline".to_string()), - (Some(_), None) => { - return Err(ToolError::new( - "MISSING_ARG", - "inline 模式必须同时给 formData 与 tablesData", - ) - .field("tablesData") - .hint("只有表单没有表结构,无法判断字段有没有对应列")); - } - _ => { - let row = self.load_visualdev(args).await?; - ( - row["formData"].as_str().unwrap_or("").to_string(), - row["tablesData"].as_str().unwrap_or("").to_string(), - row["id"].as_str().unwrap_or("").to_string(), - ) - } - }; - - if form_text.trim().is_empty() || tables_text.trim().is_empty() { - return Err(ToolError::new( - "FORM_INCOMPLETE", - "该功能缺少 f_form_data 或 f_tables_data,无法校验", - ) - .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); - } - - let fv: Value = serde_json::from_str(&form_text) - .map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?; - let tv: Value = serde_json::from_str(&tables_text) - .map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?; - - let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?; - let model = sspf_lowcode::ModelSchema::parse(&tv).map_err(|e| { - ToolError::new(e.code(), e.message()).field("tablesData") - })?; - - let report = sspf_lowcode::validate(&form, &model); - let mut out = report.to_json(); - out["source"] = json!(source); - out["summary"] = json!(format!( - "{} 个错误 / {} 个警告;{}", - report.error_count(), - report.warn_count(), - if report.ok() { - "设计稿自洽(注意:与真实数据库列的一致性未验)" - } else { - "设计稿不自洽,上动态 CRUD 前必须修" - } - )); - Ok(out) - } - - // ================================================================ - // 低代码动态 CRUD(P2-b) - // ================================================================ - - /// 🔴 加载低代码功能并解析出(表单, 模型)。 - /// - /// `id` / `enCode` 二选一 —— 与 `form.validate` 同一套加载逻辑。 - async fn load_lowcode( - &self, - args: &Value, - ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { - let row = self.load_visualdev(args).await?; - Self::lowcode_from_row(&row) - } - - /// 从 `base_visual_dev` 的一行解析出(表单, 模型)。 - fn lowcode_from_row( - row: &Value, - ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { - Self::lowcode_from_json( - row["formData"].as_str().unwrap_or(""), - row["tablesData"].as_str().unwrap_or(""), - ) - } - - /// 🔴 解析设计稿(`f_form_data` + `f_tables_data`)—— 库内行与内联入参共用。 - fn lowcode_from_json( - form_text: &str, - tables_text: &str, - ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { - let form_text = form_text.trim(); - let tables_text = tables_text.trim(); - - if form_text.is_empty() || tables_text.is_empty() { - return Err(ToolError::new( - "FORM_INCOMPLETE", - "该功能缺少 f_form_data 或 f_tables_data,无法动态 CRUD", - ) - .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); - } - - let fv: Value = serde_json::from_str(form_text) - .map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?; - let tv: Value = serde_json::from_str(tables_text) - .map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?; - - let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?; - let model = sspf_lowcode::ModelSchema::parse(&tv) - .map_err(|e| ToolError::new(e.code(), e.message()).field("tablesData"))?; - - Ok((form, model)) - } - - /// 🔴 取入参里的数据体(必须是对象)。 - fn record_payload(args: &Value) -> Result { - let data = args.get("data").cloned().unwrap_or_else(|| json!({})); - if !data.is_object() { - return Err(ToolError::new("BAD_ARG", "data 必须是对象").field("data")); - } - Ok(data) - } - - /// 🔴 `dryRun` 的默认值是 **true** —— 写工具先看再写。 - fn dry_run_flag(args: &Value) -> bool { - args.get("dryRun") - .and_then(Value::as_bool) - .unwrap_or(true) - } - - /// 把执行结果整理成工具输出。 - fn crud_json(outcome: &crate::lowcode_crud::CrudOutcome) -> Value { - let statements: Vec = outcome - .sql - .iter() - .map(|s| { - json!({ - "kind": s.kind_str(), - "table": s.table, - "sql": s.text, - "params": s.params, - "columns": s.param_columns, - }) - }) - .collect(); - json!({ - "id": outcome.id, - "dryRun": outcome.dry_run, - "statements": outcome.statements, - "sql": statements, - "notes": outcome.notes, - }) - } - - /// `schema.table.create` —— 按设计稿建物理表,并回写 `f_tables_data`。 - /// - /// 两种模式: - /// - /// | 模式 | 入参 | 能落库吗 | - /// |---|---|---| - /// | 库内功能 | `id` / `enCode` | ✅(`dryRun=false` 时建表 + 回写) | - /// | 内联设计稿 | `formData` + `tablesData` | ❌ 只能演练(没有回写目标) | - /// - /// 🔴 内联模式的意义:设计稿还没入库时就能看到 DDL —— - /// 与 `form.validate` 的 inline 模式同款,也方便冒烟脚本钉住建表规则。 - async fn schema_table_create(&self, args: &Value) -> Result { - let dry_run = Self::dry_run_flag(args); - - let inline_form = args - .get("formData") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - let inline_tables = args - .get("tablesData") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - - // ---- 内联设计稿:只能演练 ---- - if !inline_form.is_empty() || !inline_tables.is_empty() { - if inline_form.is_empty() || inline_tables.is_empty() { - let missing = if inline_form.is_empty() { - "formData" - } else { - "tablesData" - }; - return Err(ToolError::new( - "MISSING_ARG", - "内联模式要同时给 formData 与 tablesData", - ) - .field(missing) - .hint( - "表单决定 logicalDelete / 主键策略,模型决定列 —— \ - 只给一半就建不出正确的表", - )); - } - if !dry_run { - return Err(ToolError::new( - "INLINE_REQUIRES_DRY_RUN", - "内联设计稿只能演练,不能落库", - ) - .field("dryRun") - .hint( - "落库要绑定一条功能记录(回写的目标)—— \ - 先把设计稿存进 base_visual_dev,再用 id / enCode 调", - )); - } - - let (form, model) = Self::lowcode_from_json(&inline_form, &inline_tables)?; - let outcome = - crate::lowcode_ddl::create_tables(&self.state.db, &model, &form, true).await?; - return Ok(Self::ddl_json(None, &outcome)); - } - - // ---- 库内功能:建表 + 回写 ---- - let row = self.load_visualdev(args).await?; - let (form, model) = Self::lowcode_from_row(&row)?; - let visualdev_id = row["id"].as_str().unwrap_or("").to_string(); - - let outcome = crate::lowcode_ddl::create_and_sync( - &self.state.db, - &visualdev_id, - &model, - &form, - dry_run, - ) - .await?; - - Ok(Self::ddl_json(Some(&visualdev_id), &outcome)) - } - - /// 把建表结果整理成工具输出。 - fn ddl_json( - visualdev_id: Option<&str>, - outcome: &crate::lowcode_ddl::CreateTablesOutcome, - ) -> Value { - json!({ - "id": visualdev_id, - "dryRun": outcome.dry_run, - "tables": outcome.tables, - "skipped": outcome.skipped, - "statements": outcome.ddl.len(), - "ddl": outcome.ddl, - "model": outcome.model, - "notes": outcome.notes, - }) - } - - /// `data.record.insert` —— 按设计稿新增一条记录(主表 + 子表)。 - async fn data_record_insert(&self, args: &Value) -> Result { - let (form, model) = self.load_lowcode(args).await?; - let payload = Self::record_payload(args)?; - let dry_run = Self::dry_run_flag(args); - let now = crate::lowcode_crud::now_iso(); - - // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), - // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 - let mut ctx = crate::lowcode_crud::build_context( - None, - Some(crate::lowcode_crud::DEFAULT_TENANT_ID), - Some(&now), - ); - - let outcome = crate::lowcode_crud::insert_record( - &self.state.db, - &form, - &model, - &payload, - &mut ctx, - dry_run, - ) - .await?; - - Ok(Self::crud_json(&outcome)) - } - - /// `data.record.update` —— 按设计稿更新一条记录(子表走差集对账)。 - async fn data_record_update(&self, args: &Value) -> Result { - let (form, model) = self.load_lowcode(args).await?; - let payload = Self::record_payload(args)?; - let dry_run = Self::dry_run_flag(args); - let now = crate::lowcode_crud::now_iso(); - - let record_id = args - .get("recordId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if record_id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "recordId 不能为空") - .field("recordId") - .hint("先用 data.query 查到记录的 id")); - } - - // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), - // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 - let mut ctx = crate::lowcode_crud::build_context( - None, - Some(crate::lowcode_crud::DEFAULT_TENANT_ID), - Some(&now), - ); - - let outcome = crate::lowcode_crud::update_record( - &self.state.db, - &form, - &model, - &payload, - &mut ctx, - &record_id, - dry_run, - ) - .await?; - - Ok(Self::crud_json(&outcome)) - } - - /// `data.record.delete` —— 删一条记录(逻辑/物理按功能的 logicalDelete)。 - async fn data_record_delete(&self, args: &Value) -> Result { - let (form, model) = self.load_lowcode(args).await?; - let dry_run = Self::dry_run_flag(args); - let now = crate::lowcode_crud::now_iso(); - - let record_id = args - .get("recordId") - .and_then(Value::as_str) - .unwrap_or("") - .trim() - .to_string(); - if record_id.is_empty() { - return Err(ToolError::new("MISSING_ARG", "recordId 不能为空") - .field("recordId") - .hint("先用 data.query 查到记录的 id")); - } - - // 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`), - // 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。 - let mut ctx = crate::lowcode_crud::build_context( - None, - Some(crate::lowcode_crud::DEFAULT_TENANT_ID), - Some(&now), - ); - - let outcome = crate::lowcode_crud::delete_record( - &self.state.db, - &form, - &model, - &mut ctx, - &record_id, - dry_run, - ) - .await?; - - Ok(Self::crud_json(&outcome)) - } -} - -/// 🔴 **不许经通用读工具投影/过滤的列**(口令与密钥)。 -/// -/// ## 为什么需要这一层 -/// -/// `data.query` / `data.count` 是「按表名读任意表」的通用口子。 -/// 不在这里挡,一句 `{"table":"base_user"}` 就能把全库口令哈希拖走 -/// (实测修复前确实返回了 `password` / `secretkey` 两列)。 -/// -/// ⇒ 三条约束: -/// 1. 缺省投影**滤掉**这些列; -/// 2. 显式 `columns` 要这些列 ⇒ `SENSITIVE_COLUMN`(不静默少给); -/// 3. `where` / `orderBy` 用它们 ⇒ 同样拒绝(否则成了「按哈希猜明文」的 oracle)。 -const SENSITIVE_COLUMNS: &[&str] = &["f_password", "f_secretkey"]; - -/// 是否敏感列(大小写不敏感 —— PG 会把标识符折叠成小写)。 -fn is_sensitive_column(name: &str) -> bool { - SENSITIVE_COLUMNS.iter().any(|c| c.eq_ignore_ascii_case(name)) -} - -/// 🔴 敏感列一律拒绝,并说清「为什么 + 去哪拿」。 -fn ensure_not_sensitive(name: &str, field: &'static str) -> Result<(), ToolError> { - if !is_sensitive_column(name) { - return Ok(()); - } - Err(ToolError::new( - "SENSITIVE_COLUMN", - format!("列 {name} 属于口令/密钥,不允许经通用读工具访问"), - ) - .field(field.to_string()) - .hint("口令列只存在于 base_user,任何工具都不投影它") - .next( - "permission.user.list", - json!({}), - "要看用户信息用这个(它本来就不返回口令字段)", - )) -} - -/// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。 -fn form_err(e: sspf_lowcode::FormError) -> ToolError { - ToolError::new(e.code(), e.message()) - .field("formData") - .hint("v4 表单的 f_form_data 是 `{formRef, fields:[…]}` 对象;\ - 流程表单是 `[{filedName,filedId,…}]` 数组 —— 后者不属于本引擎处理范围") -} - -/// 把解析结果组织成 `form.describe` 的输出。 -fn describe_json( - form: &sspf_lowcode::FormSchema, - row: Option<&Value>, - args: &Value, -) -> Value { - let main = form.main_fields(); - let subs = form.sub_tables(); - - let field_brief = |f: &sspf_lowcode::FieldNode| { - json!({ - "vModel": f.v_model, - "column": f.column_name(), - "label": f.label, - "jnpfKey": f.jnpf_key, - "widget": f.widget.as_str(), - "required": f.required, - "acceptsInput": f.widget.accepts_input(), - "visibility": f.visibility, - }) - }; - - let mut out = json!({ - "formRef": form.form_ref, - "formModel": form.form_model, - "labelPosition": form.label_position, - "labelWidth": form.label_width, - "primaryKeyPolicy": form.primary_key_policy, - "mainFields": main.iter().map(|f| field_brief(f)).collect::>(), - "subTables": subs.iter().map(|s| json!({ - "label": s.label, - "tableName": s.table_name, - "vModel": s.v_model, - "fields": s.children.iter() - .filter(|c| c.widget.occupies_column()) - .map(|c| field_brief(c)) - .collect::>(), - })).collect::>(), - "unknownWidgets": form.unknown_widgets().iter() - .map(|n| json!({"jnpfKey": n.jnpf_key, "label": n.label})) - .collect::>(), - "counts": { - "mainFields": main.len(), - "subTables": subs.len(), - }, - }); - - if let Some(r) = row { - out["id"] = r["id"].clone(); - out["fullName"] = r["fullName"].clone(); - out["enCode"] = r["enCode"].clone(); - out["type"] = r["type"].clone(); - out["state"] = r["state"].clone(); - } - - // 只有明确要求时才回原文(一张表单可能几十 KB) - if args.get("withRaw").and_then(Value::as_bool).unwrap_or(false) { - out["raw"] = form.raw.clone(); - } - - out -} - -/// 去重并保持稳定顺序(BTreeSet 排序,避免每次调用结果顺序漂移)。 -fn dedup(items: &[String]) -> Vec { - let set: std::collections::BTreeSet<&String> = items.iter().collect(); - set.into_iter().cloned().collect() -} - -/// 把 pglite 错误转成结构化的工具错误(AI 能看懂的那种)。 -fn db_err(e: pglite::Error) -> ToolError { - ToolError::new("DB_ERROR", format!("数据库错误: {e}")) - .hint("多数是 SQL 与当前 schema 不匹配;先 schema.table.list 确认表在不在") - .retryable() -} - -impl PlatformAdapter for NativeAdapter { - fn describe_env<'a>(&'a self) -> BoxFut<'a, EnvInfo> { - Box::pin(async move { - let system_id = self.main_system_id().await; - let tables = self.table_count().await; - - // 能力域 = 注册表里实际有工具的分类(不靠硬编码清单,避免「声称支持但没工具」) - let mut caps: Vec = sspf_mcp::Registry::global() - .all() - .iter() - .map(|t| t.category.as_str().to_string()) - .collect(); - caps.sort(); - caps.dedup(); - - EnvInfo { - backend: "native".to_string(), - version: env!("CARGO_PKG_VERSION").to_string(), - app_code: system_id.clone(), - system_id, - // 🔴 进程内适配器没有登录态:它本身就是管理员视角。 - user: None, - tables, - capabilities: caps, - } - }) - } - - fn invoke<'a>(&'a self, op: &'a str, args: Value) -> BoxFut<'a, Result> { - Box::pin(async move { - match op { - // ------------------------------------------------ 上下文 - "context.get" => { - let system_id = self.main_system_id().await; - let tables = self.table_count().await; - Ok(json!({ - "backend": "native", - "version": env!("CARGO_PKG_VERSION"), - "app_code": system_id, - "system_id": system_id, - "tables": tables, - })) - } - - // ------------------------------------------------ 表清单 - "schema.table.list" => { - let prefix = args - .get("prefix") - .and_then(Value::as_str) - .unwrap_or("") - .to_string(); - - let rows = self - .state - .db - .query_json( - "SELECT t.table_name AS \"name\", \ - (SELECT count(*) FROM information_schema.columns c \ - WHERE c.table_schema = t.table_schema AND c.table_name = t.table_name)::int \ - AS \"columns\" \ - FROM information_schema.tables t \ - WHERE t.table_schema = 'public' AND t.table_type = 'BASE TABLE' \ - ORDER BY t.table_name", - ) - .await - .map_err(db_err)?; - - let filtered: Vec = rows - .into_iter() - .filter(|r| { - prefix.is_empty() - || r["name"].as_str().is_some_and(|n| n.starts_with(&prefix)) - }) - .collect(); - - Ok(json!({ - "count": filtered.len(), - "prefix": if prefix.is_empty() { Value::Null } else { json!(prefix) }, - "tables": filtered, - })) - } - - // ------------------------------------------------ 表结构 - "schema.table.describe" => { - let raw = args.get("table").and_then(Value::as_str).unwrap_or(""); - // 🔴 表名只走白名单(`valid_table`),绝不拼接用户输入 - let Some(table) = valid_table(raw) else { - return Err(ToolError::new( - "INVALID_TABLE", - format!("表名不合法: {raw}"), - ) - .field("table") - .hint("只接受小写字母/数字/下划线,且必须以 f_ 或业务前缀开头") - .next( - "schema.table.list", - json!({}), - "先列出所有表,再挑一个", - )); - }; - - let rows = self - .state - .db - .query_json_params( - "SELECT column_name AS \"name\", \ - data_type AS \"type\", \ - is_nullable AS \"nullable\", \ - COALESCE(column_default, '') AS \"default\" \ - FROM information_schema.columns \ - WHERE table_schema = 'public' AND table_name = $1 \ - ORDER BY ordinal_position", - &[&table], - ) - .await - .map_err(db_err)?; - - if rows.is_empty() { - return Err(ToolError::new( - "TABLE_NOT_FOUND", - format!("表 {table} 不存在"), - ) - .field("table") - .next("schema.table.list", json!({}), "确认表名")); - } - - Ok(json!({ - "table": table, - "column_count": rows.len(), - "columns": rows, - })) - } - - // ------------------------------------------------ 菜单树 - "menu.tree" => { - let flat = args.get("flat").and_then(Value::as_bool).unwrap_or(false); - let system_id = self.main_system_id().await; - - let rows = self - .state - .db - .query_json_params( - "SELECT f_id AS \"id\", \ - f_parent_id AS \"parentId\", \ - f_full_name AS \"fullName\", \ - COALESCE(f_en_code, '') AS \"enCode\", \ - COALESCE(f_url_address, '') AS \"urlAddress\", \ - f_type AS \"type\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\" \ - FROM base_module \ - WHERE f_delete_mark = 0 AND f_system_id = $1 \ - ORDER BY f_sort_code, f_full_name", - &[&system_id], - ) - .await - .map_err(db_err)?; - - if flat { - return Ok(json!({ - "system_id": system_id, - "mode": "flat", - "count": rows.len(), - "menus": rows, - })); - } - - // 建树(父不存在的节点挂到根,避免脏数据导致整棵树消失) - let mut children: std::collections::BTreeMap> = - std::collections::BTreeMap::new(); - let mut ids = std::collections::HashSet::new(); - for r in &rows { - if let Some(id) = r["id"].as_str() { - ids.insert(id.to_string()); - } - } - for r in rows { - let parent = r["parentId"].as_str().unwrap_or("0").to_string(); - let key = if ids.contains(&parent) { parent } else { "0".to_string() }; - children.entry(key).or_default().push(r); - } - - /// 递归组装(深度上限防御脏数据造成环)。 - fn build( - parent: &str, - children: &std::collections::BTreeMap>, - depth: usize, - ) -> Vec { - if depth > 32 { - return Vec::new(); - } - let Some(nodes) = children.get(parent) else { - return Vec::new(); - }; - nodes - .iter() - .map(|n| { - let id = n["id"].as_str().unwrap_or("").to_string(); - let mut node = n.clone(); - node["children"] = Value::Array(build(&id, children, depth + 1)); - node - }) - .collect() - } - - let tree = build("0", &children, 0); - Ok(json!({ - "system_id": system_id, - "mode": "tree", - "count": ids.len(), - "menus": tree, - })) - } - - // ------------------------------------------------ 权限(只读) - "permission.role.list" => self.role_list(&args).await, - "permission.user.list" => self.user_list(&args).await, - "permission.authorize.list" => self.authorize_list(&args).await, - - // ------------------------------------------------ 字典(只读) - "dict.type.list" => self.dict_type_list(&args).await, - "dict.data.list" => self.dict_data_list(&args).await, - - // ------------------------------------------------ 数据(只读) - "data.query" => self.data_query(&args).await, - "data.count" => self.data_count(&args).await, - - // ------------------------------------------------ 索引 - "schema.index.list" => self.index_list(&args).await, - - // ------------------------------------------------ 写(第三批) - "menu.create" => self.menu_create(&args).await, - "menu.delete" => self.menu_delete(&args).await, - "dict.type.create" => self.dict_type_create(&args).await, - - // ------------------------------------------------ 授权(第四批) - "permission.authorize.grant" => self.authorize_grant(&args).await, - "permission.authorize.revoke" => self.authorize_revoke(&args).await, - "permission.effective" => self.permission_effective(&args).await, - "permission.user.create" => self.user_create(&args).await, - - // ------------------------------------------------ 低代码(P2-a,只读) - "form.list" => self.form_list(&args).await, - "form.describe" => self.form_describe(&args).await, - "form.validate" => self.form_validate(&args).await, - - // ------------------------------------------------ 低代码动态 CRUD(P2-b,写) - "schema.table.create" => self.schema_table_create(&args).await, - "data.record.insert" => self.data_record_insert(&args).await, - "data.record.update" => self.data_record_update(&args).await, - "data.record.delete" => self.data_record_delete(&args).await, - - // ------------------------------------------------ 流程(直调契约面 handler) - "workflow.template.list" => { - crate::mcp_compat::workflow_template_list(&self.state, args).await - } - "workflow.template.info" => { - crate::mcp_compat::workflow_template_info(&self.state, args).await - } - "workflow.template.create" => { - crate::mcp_compat::workflow_template_create(&self.state, args).await - } - "workflow.template.update" => { - crate::mcp_compat::workflow_template_update(&self.state, args).await - } - "workflow.template.delete" => { - crate::mcp_compat::workflow_template_delete(&self.state, args).await - } - "workflow.template.selector" => { - crate::mcp_compat::workflow_template_selector(&self.state, args).await - } - "workflow.task.list" => { - crate::mcp_compat::workflow_task_list(&self.state, args).await - } - - // ------------------------------------------------ 字典 / 菜单(写) - "dict.type.update" => crate::mcp_compat::dict_type_update(&self.state, args).await, - "dict.type.delete" => crate::mcp_compat::dict_type_delete(&self.state, args).await, - "dict.data.create" => crate::mcp_compat::dict_data_create(&self.state, args).await, - "menu.info" => crate::mcp_compat::menu_info(&self.state, args).await, - "menu.update" => crate::mcp_compat::menu_update(&self.state, args).await, - - // ------------------------------------------------ 权限(角色 / 用户) - "permission.role.create" => { - crate::mcp_compat::role_create(&self.state, args).await - } - "permission.role.delete" => { - crate::mcp_compat::role_delete(&self.state, args).await - } - "permission.user.delete" => { - crate::mcp_compat::user_delete(&self.state, args).await - } - - // ------------------------------------------------ 低代码表单(写 / 发布) - "form.create" => crate::mcp_compat::form_create(&self.state, args).await, - "form.update" => crate::mcp_compat::form_update(&self.state, args).await, - "form.delete" => crate::mcp_compat::form_delete(&self.state, args).await, - "form.release" => crate::mcp_compat::form_release(&self.state, args).await, - - // ------------------------------------------------ 应用 / 运维 - "context.app.list" => crate::mcp_compat::app_list(&self.state, args).await, - "permission.organize.tree" => { - crate::mcp_compat::organize_tree(&self.state, args).await - } - "form.selector" => crate::mcp_compat::form_selector(&self.state, args).await, - "ops.db.stats" => crate::mcp_compat::ops_db_stats(&self.state, args).await, - "ops.health" => crate::mcp_compat::ops_health(&self.state, args).await, - "ops.logs" => crate::mcp_compat::ops_logs(&self.state, args).await, - "ops.online" => crate::mcp_compat::ops_online(&self.state, args).await, - "ops.schedule.list" => { - crate::mcp_compat::ops_schedule_list(&self.state, args).await - } - - other => Err(ToolError::new( - "OP_NOT_IMPLEMENTED", - format!("原生适配器还没实现 op: {other}"), - ) - .hint("该工具已注册但后端未实现;先在 tools/mod.rs 里摘掉或补实现") - .next( - "sspf_discover", - json!({}), - "看看还有哪些工具可用", - )), - } - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 🔴 表名白名单必须挡住注入尝试 —— 这是 `schema.table.describe` 的唯一安全边界。 - #[test] - fn table_name_whitelist_blocks_injection() { - assert!(valid_table("asset_data_resource").is_some()); - assert!(valid_table("base_user").is_some()); - assert!(valid_table("users; DROP TABLE base_user").is_none()); - assert!(valid_table("base_user--").is_none()); - assert!(valid_table("").is_none()); - } - - /// 🔴 口令/密钥列必须在通用读工具入口就被挡住。 - #[test] - fn sensitive_columns_are_blocked() { - assert!(is_sensitive_column("f_password")); - assert!(is_sensitive_column("F_PASSWORD"), "PG 折叠大小写,判断要不敏感"); - assert!(is_sensitive_column("f_secretkey")); - assert!(!is_sensitive_column("f_account")); - let e = ensure_not_sensitive("f_password", "columns").unwrap_err(); - assert_eq!(e.code, "SENSITIVE_COLUMN"); - assert!(!e.hints.is_empty(), "拒绝时要说清去哪拿用户信息"); - assert!(ensure_not_sensitive("f_account", "columns").is_ok()); - } - - /// 错误对象必须带 next_actions(AI 自纠的依据)。 - #[test] - fn db_error_carries_hint_and_is_retryable() { - // 构造一个 pglite 错误比较麻烦,这里只校验 ToolError 的形状约定 - let e = ToolError::new("DB_ERROR", "x").retryable().hint("y"); - assert!(e.retryable); - assert_eq!(e.hints.len(), 1); - } -} +pub use sspf_mcp_adapter::mcp_adapter::*; diff --git a/src/backend/src/mcp_compat.rs b/src/backend/src/mcp_compat.rs index dbaeba8..93ebb7d 100644 --- a/src/backend/src/mcp_compat.rs +++ b/src/backend/src/mcp_compat.rs @@ -1,631 +1,5 @@ -//! mcp_compat —— MCP 工具对**契约面 handler** 的进程内直调。 -//! -//! ## 为什么直调 handler,而不是重写一遍 SQL -//! -//! MCP 与 HTTP 是同一套能力的两个入口。若 MCP 自己拼 SQL,两边会**双份实现**: -//! 校验规则、默认值、软删语义、审计列都会各写一遍 ⇒ 必然漂移(dacli 踩过: -//! 50+ 处漂移修了 6 周)。这里直接调 `platform::compat::*` 的 handler -//! (与 HTTP 路由注册的是同一个函数),语义天然一致。 -//! -//! ## 身份从哪来 -//! -//! 进程内没有 HTTP 登录态。这里给 handler 造一套**管理员请求头**: -//! 用 `SessionStore::issue` 签发一个 `admin` 会话(与 HTTP 登录同一个表), -//! 再把 token 塞进 `Authorization`。`App-Code` 默认 `mainSystem`,可由工具入参覆盖。 -//! -//! 🔴 **等价于「本地 AI 就是管理员」** —— 与 `mcp_adapter.rs` 顶部的安全前提一致: -//! 该适配器只用于本地开发;对外暴露必须走 `BaselineHttpAdapter` 带真实 token。 -//! -//! ## 失败怎么报 -//! -//! handler 返回 `ActionResult{code,msg,data}`: -//! - `code=200` ⇒ 透传 `data`;`data` 为 null 时回 `{ok:true,msg}`(保留官方提示语) -//! - 其它 ⇒ `ToolError`(`BUSINESS_FAILED` / `NO_PERMISSION` / `NOT_LOGGED_IN`), -//! 带 `hints + next_actions`,让 AI 自己改参数而不是原样重试。 +//! mcp_compat —— **转发壳**:真源在 [`sspf_mcp_adapter::mcp_compat`](M6 MCP 适配层下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M6。 -use std::collections::HashMap; -use std::sync::{Arc, Mutex, OnceLock}; - -use axum::body::Bytes; -use axum::extract::{Path, RawQuery, State}; -use axum::http::HeaderMap; -use serde_json::{json, Map, Value}; - -use sspf_mcp::adapter::ToolError; - -use crate::platform::envelope::ActionResult; -use crate::platform::state::AppState; - -/// handler 调用用的管理员头 —— **按 `SessionStore` 实例缓存**。 -/// -/// 🔴 不能用全局单例:测试里每个用例一个 `AppState`(各自一张 token 表), -/// 全局缓存的 token 在别的表里解析不出来 ⇒ 所有工具都 602。 -static ADMIN_HEADERS: OnceLock, HeaderMap)>>> = - OnceLock::new(); - -/// 管理员头缓存的**上界**。 -/// -/// 正常进程只有 1 个 `AppState`(1 条);测试里每个用例一个实例 ⇒ 不设界会随用例数增长。 -/// 满了直接清空(代价只是下次多签一个 token),**不做 LRU** —— 这里是缓存不是状态。 -const MAX_ADMIN_HEADER_CACHE: usize = 8; - -/// 造/复用管理员请求头,并按入参覆盖 `App-Code`。 -async fn headers(state: &AppState, args: &Value) -> HeaderMap { - let key = Arc::as_ptr(&state.sessions) as usize; - let cached = ADMIN_HEADERS - .get_or_init(|| Mutex::new(HashMap::new())) - .lock() - .ok() - .and_then(|m| m.get(&key).map(|(_, h)| h.clone())); - - let base = match cached { - Some(h) => h, - None => { - let mut h = HeaderMap::new(); - let admin_id = state - .db - .scalar_text("SELECT f_id FROM base_user WHERE f_account = 'admin' LIMIT 1") - .await - .ok() - .flatten() - .unwrap_or_default(); - let token = state.sessions.issue("admin", &admin_id, 1); - if let Ok(v) = token.parse() { - h.insert("authorization", v); - } - if let Ok(v) = "3".parse() { - h.insert("vue-version", v); - } - if let Ok(mut m) = ADMIN_HEADERS - .get_or_init(|| Mutex::new(HashMap::new())) - .lock() - { - if m.len() >= MAX_ADMIN_HEADER_CACHE { - m.clear(); - } - // 🔴 连同 Arc 一起存:地址可能被分配器复用,只存 headers 会让 - // 新 AppState 命中旧 token(测试里表现为随机 602)。 - m.insert(key, (Arc::clone(&state.sessions), h.clone())); - } - h - } - }; - - let mut h = base; - let app = args - .get("appCode") - .and_then(Value::as_str) - .unwrap_or("mainSystem"); - if let Ok(v) = app.parse() { - h.insert("app-code", v); - } - h -} - -/// 从入参挑出若干键,拼成 URL query(中文等字符会被正确百分号编码)。 -fn qs(args: &Value, keys: &[&str]) -> String { - let Some(obj) = args.as_object() else { - return String::new(); - }; - let mut pairs: Vec<(String, String)> = Vec::new(); - for k in keys { - let Some(v) = obj.get(*k) else { continue }; - if v.is_null() { - continue; - } - let s = match v { - Value::String(s) => s.clone(), - other => other.to_string(), - }; - if s.is_empty() { - continue; - } - pairs.push(((*k).to_string(), s)); - } - serde_urlencoded::to_string(&pairs).unwrap_or_default() -} - -/// 入参原样当 body(去掉 MCP 控制字段)。 -/// -/// 🔴 **`formData` / `columnData` / `tablesData` 这类列是 TEXT,但 handler 的 -/// `value_to_text()` 只接受 string/number/bool —— 传对象会被**静默丢弃**。** -/// ⇒ 这里统一把对象/数组序列化成 JSON 字符串,AI 可以直接写对象。 -fn body_of(args: &Value) -> Result { - let mut v = args.clone(); - if let Some(o) = v.as_object_mut() { - o.remove("dryRun"); - o.remove("appCode"); - for key in [ - "formData", - "columnData", - "tablesData", - "appColumnData", - "buttonData", - "appButtonData", - "interfaceParam", - ] { - let Some(slot) = o.get_mut(key) else { continue }; - if slot.is_object() || slot.is_array() { - let text = serde_json::to_string(slot).unwrap_or_default(); - *slot = Value::String(text); - } - } - } - if !v.is_object() { - return Err(ToolError::new("BAD_ARGS", "入参必须是 JSON 对象").field("args")); - } - serde_json::to_vec(&v) - .map(Bytes::from) - .map_err(|e| ToolError::new("BAD_ARGS", format!("序列化入参失败: {e}"))) -} - -/// 取必填字符串参数。 -fn need_str(args: &Value, key: &str) -> Result { - let s = args.get(key).and_then(Value::as_str).unwrap_or("").trim(); - if s.is_empty() { - return Err(ToolError::new("MISSING_ARG", format!("缺少必填参数 {key}")) - .field(key) - .hint("先 sspf_describe 看该工具的 input_schema") - .next("sspf_discover", json!({}), "先确认该用哪个工具")); - } - Ok(s.to_string()) -} - -/// 该域的「查证」工具 —— 业务失败时建议 AI 先列一下再改参数。 -fn next_tool_for(op: &str) -> Option<&'static str> { - if op.starts_with("workflow.") { - Some("workflow.template.list") - } else if op.starts_with("dict.") { - Some("dict.type.list") - } else if op.starts_with("menu.") { - Some("menu.tree") - } else if op.starts_with("permission.role.") { - Some("permission.role.list") - } else if op.starts_with("permission.user.") { - Some("permission.user.list") - } else if op.starts_with("form.") { - Some("form.list") - } else { - None - } -} - -/// `Json` ⇒ 工具结果 / 结构化错误。 -fn out(op: &str, resp: axum::Json) -> Result { - let a = resp.0; - if a.code == 200 { - return Ok(match a.data { - // 新建设备类端点常返裸 id 字符串(官方 `ActionResult.success(id)`)—— - // 包成 `{id}` 让 AI 拿到稳定字段,不用猜「这串是什么」。 - Value::String(s) => json!({ "id": s }), - Value::Null => json!({ "ok": true, "msg": a.msg }), - other => other, - }); - } - let code = match a.code { - 602 => "NOT_LOGGED_IN", - 403 => "NO_PERMISSION", - _ => "BUSINESS_FAILED", - }; - let mut err = ToolError::new(code, a.msg).hint("先 sspf_describe 看该工具的 pitfalls 与示例"); - if let Some(t) = next_tool_for(op) { - err = err.next(t, json!({}), "先列出现有数据,确认 id / enCode 是否正确"); - } - Err(err) -} - -// ================================================================ workflow - -pub async fn workflow_template_list(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &["keyword", "category", "type", "state", "currentPage", "pageSize"], - ))); - let r = crate::platform::compat::workflow::workflow_template_list( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("workflow.template.list", r) -} - -pub async fn workflow_template_info(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::workflow::workflow_template_info( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("workflow.template.info", r) -} - -pub async fn workflow_template_create(state: &AppState, args: Value) -> Result { - let body = body_of(&args)?; - let r = crate::platform::compat::workflow::workflow_template_create( - State(state.clone()), - headers(state, &args).await, - body, - ) - .await; - out("workflow.template.create", r) -} - -pub async fn workflow_template_update(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let body = body_of(&args)?; - let r = crate::platform::compat::workflow::workflow_template_update( - State(state.clone()), - headers(state, &args).await, - Path(id), - body, - ) - .await; - out("workflow.template.update", r) -} - -pub async fn workflow_template_delete(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::workflow::workflow_template_delete( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("workflow.template.delete", r) -} - -pub async fn workflow_task_list(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &["keyword", "type", "category", "currentPage", "pageSize"], - ))); - let r = crate::platform::compat::workflow::workflow_task_list( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("workflow.task.list", r) -} - -pub async fn workflow_template_selector(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &["keyword", "category", "type", "currentPage", "pageSize"], - ))); - let r = crate::platform::compat::workflow::workflow_template_selector( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("workflow.template.selector", r) -} - -// ================================================================ dict - -pub async fn dict_type_update(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let body = body_of(&args)?; - let r = crate::platform::compat::system::dict_type_update( - State(state.clone()), - headers(state, &args).await, - Path(id), - body, - ) - .await; - out("dict.type.update", r) -} - -pub async fn dict_type_delete(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::system::dict_type_delete( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("dict.type.delete", r) -} - -pub async fn dict_data_create(state: &AppState, args: Value) -> Result { - let body = body_of(&args)?; - let r = crate::platform::compat::system::dict_data_create( - State(state.clone()), - headers(state, &args).await, - body, - ) - .await; - out("dict.data.create", r) -} - -// ================================================================ menu - -pub async fn menu_info(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::system::menu_info( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("menu.info", r) -} - -pub async fn menu_update(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let body = body_of(&args)?; - let r = crate::platform::compat::system::menu_update( - State(state.clone()), - headers(state, &args).await, - Path(id), - body, - ) - .await; - out("menu.update", r) -} - -// ================================================================ permission - -pub async fn role_create(state: &AppState, args: Value) -> Result { - let body = body_of(&args)?; - let r = crate::platform::compat::permission::role_create( - State(state.clone()), - headers(state, &args).await, - body, - ) - .await; - out("permission.role.create", r) -} - -pub async fn role_delete(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::permission::role_delete( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("permission.role.delete", r) -} - -pub async fn user_delete(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::permission::user_delete( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("permission.user.delete", r) -} - -// ================================================================ form - -pub async fn form_create(state: &AppState, args: Value) -> Result { - let body = body_of(&args)?; - let r = crate::platform::compat::online_dev::visual_dev_create( - State(state.clone()), - headers(state, &args).await, - body, - ) - .await; - out("form.create", r) -} - -pub async fn form_update(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let body = body_of(&args)?; - let r = crate::platform::compat::online_dev::visual_dev_update( - State(state.clone()), - headers(state, &args).await, - Path(id), - body, - ) - .await; - out("form.update", r) -} - -pub async fn form_delete(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::online_dev::visual_dev_delete( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("form.delete", r) -} - -pub async fn form_release(state: &AppState, args: Value) -> Result { - let id = need_str(&args, "id")?; - let r = crate::platform::compat::online_dev::visual_dev_release( - State(state.clone()), - headers(state, &args).await, - Path(id), - ) - .await; - out("form.release", r) -} - -// ================================================================ context / ops - -pub async fn app_list(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &["keyword", "type", "currentPage", "pageSize"], - ))); - let r = crate::platform::compat::system::system_list( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("context.app.list", r) -} - -pub async fn ops_logs(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &[ - "category", - "keyword", - "startTime", - "endTime", - "currentPage", - "pageSize", - ], - ))); - let r = crate::platform::compat::system::log_list( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("ops.logs", r) -} - -pub async fn ops_schedule_list(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &["keyword", "currentPage", "pageSize"], - ))); - let r = crate::platform::compat::scheduletask::task_list( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("ops.schedule.list", r) -} - -/// 健康检查:表数 / 会话数 / admin 是否在 —— 不走 HTTP,直接读库。 -pub async fn ops_health(state: &AppState, _args: Value) -> Result { - let tables = state - .db - .scalar_text( - "SELECT count(*)::text FROM information_schema.tables \ - WHERE table_schema = 'public' AND table_type = 'BASE TABLE'", - ) - .await - .ok() - .flatten() - .and_then(|s| s.parse::().ok()) - .unwrap_or(0); - let admin = state - .db - .scalar_text("SELECT f_account FROM base_user WHERE f_account = 'admin' LIMIT 1") - .await - .ok() - .flatten(); - let sessions = state.sessions.snapshot(); - Ok(json!({ - "backend": "native", - "version": env!("CARGO_PKG_VERSION"), - "tables": tables, - "adminSeeded": admin.is_some(), - "sessions": sessions.len(), - })) -} - -/// 在线会话:**按账号聚合**,不返回 token 本身(token 是凭据,不进工具输出)。 -pub async fn ops_online(state: &AppState, _args: Value) -> Result { - let snap = state.sessions.snapshot(); - let mut by_account: Map = Map::new(); - for (_, u) in snap { - let entry = by_account.entry(u.account.clone()).or_insert_with(|| { - json!({ - "account": u.account, - "isAdmin": u.is_admin == 1, - "sessions": 0, - "lastIssuedAtMs": 0, - "ips": Vec::::new(), - }) - }); - if let Some(o) = entry.as_object_mut() { - let n = o.get("sessions").and_then(Value::as_i64).unwrap_or(0) + 1; - o.insert("sessions".to_string(), json!(n)); - let last = o.get("lastIssuedAtMs").and_then(Value::as_i64).unwrap_or(0); - o.insert("lastIssuedAtMs".to_string(), json!(last.max(u.issued_at_ms))); - if !u.ip.is_empty() { - if let Some(arr) = o.get_mut("ips").and_then(Value::as_array_mut) { - if !arr.iter().any(|v| v.as_str() == Some(u.ip.as_str())) { - arr.push(json!(u.ip)); - } - } - } - } - } - Ok(json!({ - "online": by_account.len(), - "users": by_account.into_values().collect::>(), - })) -} - -// ================================================================ 机构树 / 表单下拉 / 库概览 - -pub async fn organize_tree(state: &AppState, args: Value) -> Result { - let r = crate::platform::compat::permission::organize_list( - State(state.clone()), - headers(state, &args).await, - ) - .await; - out("permission.organize.tree", r) -} - -pub async fn form_selector(state: &AppState, args: Value) -> Result { - let raw = RawQuery(Some(qs( - &args, - &[ - "keyword", - "type", - "isRelease", - "webType", - "currentPage", - "pageSize", - ], - ))); - let r = crate::platform::compat::online_dev::visual_dev_selector( - State(state.clone()), - headers(state, &args).await, - raw, - ) - .await; - out("form.selector", r) -} - -/// 库概览:关键表行数 + 数据库体积(排障时判断「空库 / 有数据 / 库太大」)。 -pub async fn ops_db_stats(state: &AppState, _args: Value) -> Result { - let mut counts = Map::new(); - for (label, table) in [ - ("users", "base_user"), - ("menus", "base_module"), - ("forms", "base_visual_dev"), - ("releasedForms", "base_visual_release"), - ("roles", "base_role"), - ("logs", "base_sys_log"), - ("workflowTemplates", "workflow_template"), - ] { - let n = state - .db - .scalar_text(&format!("SELECT count(*)::text FROM {table}")) - .await - .ok() - .flatten() - .and_then(|s| s.parse::().ok()) - .unwrap_or(-1); - counts.insert(label.to_string(), json!(n)); - } - let size = state - .db - .scalar_text("SELECT pg_database_size(current_database())::text") - .await - .ok() - .flatten(); - Ok(json!({ - "counts": counts, - "databaseBytes": size, - })) -} +pub use sspf_mcp_adapter::mcp_compat::*;