1 Commits
Author SHA1 Message Date
admin 210a885f79 refactor(arch): M6 MCP 适配层下沉 —— 2 模块 / 3,283 行迁入 sspf-mcp-adapter
迁入 src/backend/src/mcp_{adapter,compat}.rs(3,283 行)到 crates/sspf-mcp-adapter/,
原路径变转发壳(pub use sspf_mcp_adapter::<mod>::*)⇒ --mcp 启动路径与集成测试零感知。

依赖(比计划瘦):sspf-mcp + sspf-core + 仅四个 compat 域包
(system/permission/workflow/online_dev)+ sspf-lowcode + sspf-lowcode-exec
+ axum + pglite-rs。原计划写「所有 compat 包」,实际 msg/ext/compat-core 不必依赖。

闸门:
- 新增 AR14(依赖白名单 + 源码不许 use sspf_pack_*),反自证 9/9
- CP1/CP2 纳入适配层真源 + 新增 CP1'' 扫描面反自证
- CP1 抓出 5 处既有业务标识符泄漏(hint 提示语与单测断言里)⇒ 已改通用形态
- 契约 [RULER] check-boundary.sh 由 11 改 12

验证:cargo build 零警告;cargo test 695/0;check-arch 19/19;
check-boundary 12/12;check-contract 10/10;check-module 123/123;
check-citations 4/4;verify.sh --smoke 14 步全绿(397.3s)
2026-11-03 21:13:22 +08:00
16 changed files with 3682 additions and 3302 deletions

No files matched your search

+33
View File
@@ -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::<mod>::*;`)⇒ `--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、可回滚。
+5 -1
View File
@@ -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(数据资源,本体对齐)
│ │ │ │ └── <app>.rs # 尚数网业务模块(Phase 3 起)
│ │ │ ├── mcp_adapter.rs # 【MCP 适配层】M6 起真源在 `crates/sspf-mcp-adapter/src/`
│ │ │ ├── mcp_compat.rs # 这里两个 .rs 只是转发壳(`pub use sspf_mcp_adapter::<mod>::*;`)
│ │ │ ├── routes.rs # 路由装配(平台 27 条 + 面 B 14 条 + merge 业务路由)
│ │ │ └── bootstrap.rs # 【装配根】唯一同时认识两层;把业务菜单注入种子
│ │ ├── db/schema.sql # 完整 DDL(base_* 8 + 业务 N)
Generated
+19
View File
@@ -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",
+52
View File
@@ -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::<mod>::*;`)⇒ **`--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<ActionResult>` |
| `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 条端点探针做过一轮真实系统性验证(报告:
+56
View File
@@ -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<ActionResult>`)
axum = { workspace = true }
# 真实库(`ToSql` 参数绑定 —— 把 JSON 值转成 SQL 参数)
pglite-rs = { workspace = true }
serde_json = { workspace = true }
serde_urlencoded = { workspace = true }
+44
View File
@@ -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;
File diff suppressed because it is too large. Load diff
+631
View File
@@ -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<Mutex<HashMap<usize, (Arc<sspf_core::session::SessionStore>, 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<Bytes, ToolError> {
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<String, ToolError> {
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<ActionResult>` ⇒ 工具结果 / 结构化错误。
fn out(op: &str, resp: axum::Json<ActionResult>) -> Result<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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::<i64>().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<Value, ToolError> {
let snap = state.sessions.snapshot();
let mut by_account: Map<String, Value> = 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::<String>::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::<Vec<_>>(),
}))
}
// ================================================================ 机构树 / 表单下拉 / 库概览
pub async fn organize_tree(state: &AppState, args: Value) -> Result<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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::<i64>().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,
}))
}
+28 -3
View File
@@ -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。
+1 -1
View File
@@ -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
```
+3 -3
View File
@@ -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`
**协议层、元工具、注册表都不用改。** 这是分层加载的直接收益。
+94 -8
View File
@@ -41,6 +41,9 @@
# —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆
# MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存
# (近似检查:`static` + `Mutex<HashMap` 必须有 `MAX` 常量同文件出现)
# AR14 `crates/sspf-mcp-adapter` 依赖 ⊆ 白名单 + 源码不许 `use sspf_pack_*`
# —— M6 把 MCP 适配层下沉成独立 crate;它是「全仓唯一知道全部包的汇聚点」
# ⇒ 依赖面必须锁死,否则它会变成第二个「什么都认识」的黑洞
#
# 🔴 AR1–AR5 是 PLAN.md §3.2 的分层纪律;MEM1–MEM2 是判断 ⑥ 的四条内存红线的静态部分。
@@ -435,6 +438,55 @@ check_ar13() {
fi
}
# ---------------------------------------------------------------- AR14
# **MCP 适配层的依赖白名单**(M6 把 `mcp_{adapter,compat}.rs` 下沉到 `sspf-mcp-adapter`)。
#
# 🔴 **为什么需要**:`sspf-mcp-adapter` 是**全仓唯一「知道全部包」的 crate** ——
# `mcp_compat.rs` 直调 workflow / system / permission / online_dev 四个契约面域包
# 的 handler ⇒ 依赖图上它是**顶层汇聚点**。
# 这本身**不是环**(被依赖方谁都不认识它 ⇒ 方向单一),但它有两个真实风险:
# ① 依赖面失控 —— 一旦拖进业务包(`sspf_pack_*`),适配层就开始认识业务
# ⇒ 破 AR9 的「平台层零业务知识」承诺;
# ② 退化成「万能壳」 —— 拖进 `sspf-contract` / `sspf-plugin` 等非必需依赖,
# 会让它变成第二个什么都认识的模块 ⇒ 迁移的收益(壳瘦下来)被抵消。
#
# 🔴 **为什么不复用 AR9**:AR9 扫的是**平台层目录**(`sspf-core` + `sspf-compat-*` +
# `platform/` 壳)。适配层是**新的目录**,AR9 扫不到 ⇒ 必须单列一条钉住
# (与 AR13 对 `sspf-lowcode-exec` 的处理同款)。
#
# 判据(两层):
# ① `crates/sspf-mcp-adapter/Cargo.toml` 的依赖 ⊆ 白名单;
# ② 该 crate 的源码里**不许**出现 `use sspf_pack_`(业务包引用)。
check_ar14() {
local f="$CRATES/sspf-mcp-adapter/Cargo.toml"
if [ ! -f "$f" ]; then
skip "AR14 sspf-mcp-adapter 不存在"
return
fi
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
# 🔴 白名单:MCP 工具层(工具契约)+ 平台核心(AppState/Db/ids/cipher/信封)
# + 契约面四个域包(handler 直调对象)+ 低代码两层(动态 CRUD 工具)
# + axum(handler 的 extractor / 信封)+ pglite-rs(ToSql 参数绑定)+ 序列化。
# **不许** sspf_pack_*(业务包)/ sspf-contract(间接依赖即可)/ sspf-plugin。
if subset_of "$deps" "sspf-mcp sspf-core sspf-compat-system sspf-compat-permission sspf-compat-workflow sspf-compat-online_dev sspf-lowcode sspf-lowcode-exec axum pglite-rs serde_json serde_urlencoded"; then
ok "AR14 sspf-mcp-adapter 依赖干净([$deps])"
else
bad "AR14 sspf-mcp-adapter 依赖越界:[$deps] —— 只许 {mcp, core, compat-*, lowcode*, axum, pglite-rs, serde*}"
fi
# 第二层:源码不许出现业务包引用
local src="$CRATES/sspf-mcp-adapter/src"
if [ -d "$src" ]; then
local hits
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$src" 2>/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/<app>.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
+53 -5
View File
@@ -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/^/ /'
+3
View File
@@ -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 / 比对真实库列 / 事务 / 回写模型。
File diff suppressed because it is too large. Load diff
+4 -630
View File
@@ -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<Mutex<HashMap<usize, (Arc<crate::platform::session::SessionStore>, 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<Bytes, ToolError> {
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<String, ToolError> {
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<ActionResult>` ⇒ 工具结果 / 结构化错误。
fn out(op: &str, resp: axum::Json<ActionResult>) -> Result<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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::<i64>().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<Value, ToolError> {
let snap = state.sessions.snapshot();
let mut by_account: Map<String, Value> = 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::<String>::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::<Vec<_>>(),
}))
}
// ================================================================ 机构树 / 表单下拉 / 库概览
pub async fn organize_tree(state: &AppState, args: Value) -> Result<Value, ToolError> {
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<Value, ToolError> {
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<Value, ToolError> {
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::<i64>().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::*;