#!/usr/bin/env bash # sspf 架构边界自检 —— crate 依赖纪律 + 内存红线 # # 目的:把 PLAN.md 判断 ②/⑥ 的架构约束变成**可执行的尺子**。 # 靠人读 Cargo.toml 守不住 —— 加依赖的人不会想到「这会让所有业务包背锅」。 # # 🔴 **纯静态**:不编译、不启动。只需要 bash + python3(macOS 自带)。 # # 用法: # bash scripts/check-arch.sh # 全查 # bash scripts/check-arch.sh --self-test # 反自证:造已知违规,必须被抓到 # # 退出码:0 全过 / 1 有 ❌ / 2 用法错 # # ── 判据 ── # AR1 `crates/sspf-sdk` 依赖只能有 `sspf-contract` # —— 业务包只依赖 sdk ⇒ sdk 多一个依赖 = 所有业务包都要背 # AR2 🔴 平台包零业务:`packs/` 不存在;若出现则业务包依赖 ⊆ {sspf-sdk, serde} # —— 业务包必须能整目录搬走 ⇒ 不许挂在 axum / tokio / pglite 上 # AR3 `crates/sspf-contract` 源码不许 `use axum|tokio|pglite|sqlx` # —— 契约层一旦有 IO,业务包就再也不是「轻依赖」 # AR4 `crates/sspf-contract` 依赖 ⊆ {serde, serde_json, uuid, http} # AR5 `crates/sspf-mcp`(若已存在)依赖 ⊆ {sspf-contract, serde, serde_json, tokio, async-trait} # —— MCP 层要能同时接「进程内内核」和「远端 Java 后端」⇒ **不许依赖内核内部** # —— tokio / async-trait 是协议实现(stdio 异步读写)所需,不是业务依赖 # AR6 `crates/sspf-adapter-baseline` 依赖 ⊆ {sspf-mcp, sspf-contract, serde, serde_json, # tokio, http, hyper, hyper-util, http-body-util, bytes} # —— 适配器只认工具契约层;依赖内核 store 就等于把第二种后端钉死在本进程旁 # AR7 `crates/sspf-lowcode` 依赖 ⊆ {sspf-contract, serde, serde_json} # —— 低代码引擎是纯计算;依赖 DB/HTTP 会让它只能在内核里跑,且测试必须起库 # AR9 平台层(真源 `crates/sspf-core/src/**` + 转发壳 `src/backend/src/platform/**`) # 里不许出现 `use sspf_pack_*` # —— 平台层不许认识任何业务包(业务知识隔离) # AR10 平台层(同上两处,不含 compat/)里不许出现 # `crate::platform::compat` —— 平台层不许**反向依赖**契约面 # —— M1 解开的环 A;拆 crate 时它就是循环依赖(编译器当天才报错 ⇒ 必须提前钉住) # AR11 `src/backend/src/platform/compat/helper.rs` 里不许 `use super::<别的模块>` # —— 契约面底座不许反向依赖契约面业务模块(helper 被 14 个模块依赖 ⇒ 即成环) # —— M1 解开的环 B/C # MEM1 非注释代码里不许出现 `SELECT *` # —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆 # MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存 # (近似检查:`static` + `Mutex/dev/null || true)" if [ -z "$hits" ]; then ok "AR3 sspf-contract 无 IO 依赖(无 axum/tokio/pglite/sqlx 的 use)" else bad "AR3 sspf-contract 出现 IO 依赖:" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR4 check_ar4() { local f="$CRATES/sspf-contract/Cargo.toml" [ -f "$f" ] || { skip "AR4 sspf-contract 不存在"; return; } local deps; deps="$(deps_of "$f" | tr '\n' ' ')" if subset_of "$deps" "serde serde_json uuid http"; then ok "AR4 sspf-contract 依赖在白名单内([$deps])" else bad "AR4 sspf-contract 依赖越界:[$deps] —— 白名单 serde/serde_json/uuid/http" fi } # ---------------------------------------------------------------- AR5 check_ar5() { local f="$CRATES/sspf-mcp/Cargo.toml" [ -f "$f" ] || { skip "AR5 sspf-mcp 不存在(P1 才落地)"; return; } local deps; deps="$(deps_of "$f" | tr '\n' ' ')" if subset_of "$deps" "sspf-contract serde serde_json tokio async-trait"; then ok "AR5 sspf-mcp 依赖干净([$deps])" else bad "AR5 sspf-mcp 依赖越界:[$deps] —— 只允许 sspf-contract/serde/serde_json/tokio/async-trait" fi } # ---------------------------------------------------------------- AR6 check_ar6() { local f="$CRATES/sspf-adapter-baseline/Cargo.toml" [ -f "$f" ] || { skip "AR6 sspf-adapter-baseline 不存在"; return; } local deps; deps="$(deps_of "$f" | tr '\n' ' ')" # 🔴 适配器只许依赖「工具契约层 + HTTP 客户端」。 # 一旦依赖 sspf-store / axum,第二种后端就只能跑在同一个内核旁边 —— 双轨失效。 if subset_of "$deps" "sspf-mcp sspf-contract serde serde_json tokio http hyper hyper-util http-body-util bytes"; then ok "AR6 sspf-adapter-baseline 依赖干净([$deps])" else bad "AR6 sspf-adapter-baseline 依赖越界:[$deps] —— 只许工具契约层 + HTTP 客户端,不许依赖内核 store" fi } # ---------------------------------------------------------------- AR7 check_ar7() { local f="$CRATES/sspf-lowcode/Cargo.toml" [ -f "$f" ] || { skip "AR7 sspf-lowcode 不存在"; return; } local deps; deps="$(deps_of "$f" | tr '\n' ' ')" # 🔴 低代码引擎必须是**纯计算**:解析 / 校验 / SQL 生成。 # 一旦依赖 pglite / axum,它就只能在内核里跑 —— CLI、MCP、离线校验工具都用不了, # 而且测试必须起数据库(现在 38 个测试 0 依赖、毫秒级)。 if subset_of "$deps" "sspf-contract serde serde_json"; then ok "AR7 sspf-lowcode 依赖干净([$deps])" else bad "AR7 sspf-lowcode 依赖越界:[$deps] —— 只许契约层 + 序列化,不许 DB / HTTP" fi } # ---------------------------------------------------------------- AR8 # 业务包装载器(`crates/sspf-plugin`)的依赖白名单。 # # 🔴 **为什么单列一条**:装载器是「业务包 ⇄ 内核」的唯一中介。 # 它一旦依赖 axum / tokio / pglite,业务包就**间接背上 web 框架**(AR2 的精神废掉), # 而且「包可整目录搬走」这个承诺再也证不了。 # 装载器只做「读清单 + 校验兼容区间 + 收集 entities/menus/routes」⇒ 纯数据。 check_ar8() { local f="$CRATES/sspf-plugin/Cargo.toml" [ -f "$f" ] || { skip "AR8 sspf-plugin 不存在(批次 12 才落地)"; return; } local deps; deps="$(deps_of "$f" | tr '\n' ' ')" if subset_of "$deps" "sspf-sdk sspf-contract serde serde_json"; then ok "AR8 sspf-plugin 依赖干净([$deps])" else bad "AR8 sspf-plugin 依赖越界:[$deps] —— 只允许 sspf-sdk/sspf-contract/serde/serde_json(不许 axum/tokio/pglite)" fi } # ---------------------------------------------------------------- AR9 # **平台层不许认识任何业务包**(业务知识隔离,红线 12)。 # # 🔴 方向是「内核 ⇒ 包」,**不是**「包 ⇒ 内核」:`src/backend/Cargo.toml` 依赖 # `sspf-pack-` 是**允许**的(装配根要装载它们); # 但**平台层**里出现 `use sspf_pack_*` ⇒ 平台层知道了 # 具体业务 ⇒ 加/删业务包就要改平台层 ⇒ 「链接就好」这个承诺是假的。 # 🔴 **M2 起平台层的真源在 `crates/sspf-core/src/`**,`src/backend/src/platform/` # 只剩转发壳(`pub use sspf_core::*`)+ 尚未搬走的 `compat/`(M3/M4)。 # ⇒ 闸门必须**两处都扫**:扫真源(管实现)+ 扫转发壳(防有人往壳里塞实现)。 # 只扫壳 = 尺子量空壳 = 虚假安全感。 check_ar9() { local dirs=() [ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR9 平台层目录不存在"; return; } dirs=("${PLAT_SRC_DIRS[@]}") local hits hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "${dirs[@]}" 2>/dev/null || true)" if [ -z "$hits" ]; then ok "AR9 平台层没有 use sspf_pack_*(业务知识没漏进 sspf-core/ / compat 各包 / platform/)" else bad "AR9 平台层出现了业务包引用(业务知识漏进平台层 ⇒ 加包要改平台层):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR10 # **平台层不许反向依赖契约面**(M1 解开的环 A,防回退)。 # # 🔴 **背景**:M1 之前 `platform/auth.rs` 里写着 # `crate::platform::compat::helper::current_user(...)` —— 平台层反过来调契约面。 # 同 crate 内这只是「层间倒挂」(能编译),但**拆 crate 时就是循环依赖**, # 编译器直接报错 ⇒ 整个迁移(M2–M6)全部卡死。 # M1 已把分流点上移到装配根(`routes.rs`),平台层不再认识契约面。 # # 🔴 **为什么必须钉住**:拆 crate 是**渐进**的 —— 在拆完之前,加回这一行 # **照样编译通过、测试照样全绿**,只有到 M2 那天才炸 ⇒ 那时候已经改了一堆东西, # 回滚成本高得多。⇒ 现在就把它拦住。 # # 判据:平台层真源(`crates/sspf-core/src/**`)与转发壳(`src/backend/src/platform/**`, # **不含 compat/**)里都不许出现 `crate::platform::compat` / `super::compat` / `crate::compat`。 check_ar10() { local dirs=() [ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR10 平台层目录不存在"; return; } dirs=("${PLAT_SRC_DIRS[@]}") local hits # 🔴 **必须排除注释行**(`//` / `//!` / `///`)—— 文档注释里的路径引用是 # **给人看的**(如 `//! (见 crate::platform::compat::helper::load_menus])`), # 不是依赖 ⇒ 不该判红。 # 🔴 纯 grep 过滤不了:`//!` 前面**没有空格** ⇒ `^\s*//` 漏掉它。 # 这里用 python3 逐行判(与 MEM1/MEM2 同一套路)。 hits="$(python3 - "${dirs[@]}" <<'PY' import os, re, sys pat = re.compile(r'(crate::platform::compat|crate::compat|super::compat)') bad = [] for root in sys.argv[1:]: for dirpath, dirnames, files in os.walk(root): dirnames[:] = [d for d in dirnames if d != 'compat'] # 契约面自己互引合法 for fn in files: if not fn.endswith('.rs'): continue p = os.path.join(dirpath, fn) try: lines = open(p, encoding='utf-8').read().splitlines() except OSError: continue for i, line in enumerate(lines, 1): s = line.strip() # 整行注释(含 `//!` / `///`)⇒ 跳过 if s.startswith('//'): continue # 行尾注释:把 `//` 之后截掉再判(`use x::y; // 说明` 里的说明不算) code = line.split('//', 1)[0] if pat.search(code): bad.append(f'{p}:{i}: {s}') for b in bad: print(b) PY )" if [ -z "$hits" ]; then ok "AR10 平台层没有反向依赖契约面(拆 crate 的前置条件仍成立)" else bad "AR10 平台层反向依赖契约面(拆 crate 时就是循环依赖 ⇒ 必须把调用点上移到装配根):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR11 # **契约面底座(helper)不许依赖契约面业务模块**(M1 解开的环 B/C,防回退)。 # # 🔴 **背景**:`compat/helper.rs` 被 **14 个**契约面模块依赖(实测)⇒ 它是底座。 # 若它反过来 `use super::system` / `use super::permission` ⇒ # 拆 crate 时 helper ↔ system / helper ↔ permission 都是**循环依赖**。 # M1 已把 `menu_node` / `official_view_path` / `USER_DETAIL_COLUMNS` / # `organize_name_of` 搬进 helper,切断了这两条边。 # # 🔴 **M3 起底座真源在 `crates/sspf-compat-core/src/helper.rs`**(壳只剩 `pub use`) # ⇒ 两处都扫(扫真源管实现 + 扫壳防塞私货)。跨 crate 形态的同一纪律 = # `sspf-compat-core` 的 Cargo.toml 不许依赖 `sspf-compat-*`(M4 的 6 个包)。 # # 判据(两处): # ① `helper.rs`(真源或壳)里不许 `use super::` 指向**非 helper 的模块**, # 也不许 `use crate::res`(同 crate 内的反向依赖); # ② `crates/sspf-compat-core/Cargo.toml` 不许依赖 `sspf-compat-*`。 check_ar11() { local files=() [ -f "$CRATES/sspf-compat-core/src/helper.rs" ] && files+=("$CRATES/sspf-compat-core/src/helper.rs") local hits="" if [ "${#files[@]}" -gt 0 ]; then # 🔴🔴 **必须用 `-H`(强制输出文件名前缀)** —— M7 起文件只有一个, # `grep -n` 只输出「行号:内容」⇒ **不含路径** ⇒ 反自证里 # `grep -q "sspf-compat-core/src/helper.rs"` **永远匹配不到** # ⇒ 尺子明明抓到了违规,自证却报「尺子是假的」(实测踩过)。 # ⇒ `-H` 保证路径在场,反自证才能**按路径**精确验证。 hits="$(grep -HnE '^[[:space:]]*(pub )?use[[:space:]]+(super::[a-z_]+|crate::res)' "${files[@]}" 2>/dev/null \ | grep -vE 'super::helper|crate::helper' || true)" fi # 跨 crate 形态:底座的 Cargo.toml 不许依赖 6 个契约面包 local toml="$CRATES/sspf-compat-core/Cargo.toml" if [ -f "$toml" ]; then local dep_hits dep_hits="$(grep -nE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null || true)" if [ -n "$dep_hits" ]; then hits="${hits:+$hits$'\n'}${dep_hits}" fi fi if [ -z "$hits" ]; then ok "AR11 契约面底座(helper/sspf-compat-core)不依赖其它契约面模块(14 个模块依赖它 ⇒ 反向依赖即成环)" else bad "AR11 契约面底座反向依赖契约面业务模块(拆 crate 时即成环):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR12 # **契约面各包之间不许互相依赖**(M4 拆 6 个包时的防环回流闸门)。 # # 🔴 **为什么需要**:M4 把 49,000 行契约面拆成 7 个 crate。各包本应**彼此独立** # (都只依赖 `sspf-compat-core` 底座 + `sspf-core` 平台核心)。 # 一旦 A 包 `use sspf_compat_b::…` 而 B 包又 `use sspf_compat_a::…` # ⇒ **循环依赖** ⇒ 编译器直接报错(但那时已经改了一堆东西,回滚成本高)。 # # 🔴 **唯一允许的两条单向依赖**(方向单一 ⇒ 不成环,已核实被依赖方不反向依赖): # · `sspf-compat-permission` → `sspf-compat-system` # (权限域用系统域的 `SYSTEM_LIST_PROJECTION` / `load_system_tops` / # `log_page` / `shape_system_list_item`) # · `sspf-compat-ext` → `sspf-compat-system` + `sspf-compat-msg` # (移动端复用系统域 `home_data` 控制台卡片 + 消息域 `send_config_select_list`) # # 判据:每个 `crates/sspf-compat-*/Cargo.toml` 里出现的 `sspf-compat-*` 依赖, # 必须在白名单内,且**白名单方向要反过来核实**(被依赖方不许依赖依赖方)。 check_ar12() { local hits="" local dir for dir in "$CRATES"/sspf-compat-*; do [ -d "$dir" ] || continue local toml="$dir/Cargo.toml" [ -f "$toml" ] || continue local self_name self_name="$(basename "$dir")" local dep for dep in $(grep -oE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null | grep -oE 'sspf-compat-[a-z_-]+' | sort -u); do # 底座(sspf-compat-core)永远允许 [ "$dep" = "sspf-compat-core" ] && continue # 白名单:按「依赖方 → 被依赖方」判定 local allowed=0 case "${self_name}:${dep}" in sspf-compat-permission:sspf-compat-system) allowed=1 ;; sspf-compat-ext:sspf-compat-system) allowed=1 ;; sspf-compat-ext:sspf-compat-msg) allowed=1 ;; esac if [ "$allowed" -eq 0 ]; then hits="${hits:+$hits$'\n'}${toml}: ${self_name} → ${dep}(不在白名单)" fi done done if [ -z "$hits" ]; then ok "AR12 契约面各包彼此独立(只依赖底座 + 两条单向白名单 ⇒ 不会成环)" else bad "AR12 契约面包之间出现了未授权依赖(跨包依赖易成环):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR13 # **低代码执行层的依赖白名单**(M5 把 `lowcode_*.rs` 下沉到 `sspf-lowcode-exec`)。 # # 🔴 **为什么需要**:`sspf-lowcode`(AR7)是**纯计算**层 —— 只认 serde,不许碰 DB/HTTP。 # M5 新增的 `sspf-lowcode-exec` 是它的**执行层**,允许连库;但依赖面必须**锁死**: # 一旦它拖进 `axum`(web 框架)⇒ 这层就再也用不了 CLI / MCP / 离线工具; # 一旦它拖进 `sspf_pack_*`(业务包)⇒ 平台层开始认识业务 ⇒ 破 AR9。 # # 判据(两层): # ① `crates/sspf-lowcode-exec/Cargo.toml` 的依赖 ⊆ 白名单; # ② 该 crate 的源码里**不许**出现 `sspf_pack_`(与 AR9 同款语义,但独立钉住 # —— AR9 只扫平台层目录,执行层是新的目录,得单独管)。 check_ar13() { local f="$CRATES/sspf-lowcode-exec/Cargo.toml" if [ ! -f "$f" ]; then skip "AR13 sspf-lowcode-exec 不存在" return fi local deps; deps="$(deps_of "$f" | tr '\n' ' ')" # 🔴 白名单:`sspf-lowcode`(纯计算)+ `sspf-core`(平台核心)+ `sspf-store`(Db 真源) # + `sspf-mcp`(ToolError)+ `pglite-rs`(真实库)+ `chrono` + `serde_json`。 # **不许** axum(web 框架)/ tokio(异步运行时,本层是同步函数 + 调用方 await)。 if subset_of "$deps" "sspf-lowcode sspf-core sspf-store sspf-mcp pglite-rs chrono serde_json"; then ok "AR13 sspf-lowcode-exec 依赖干净([$deps])" else bad "AR13 sspf-lowcode-exec 依赖越界:[$deps] —— 只许 {lowcode, core, store, mcp, pglite-rs, chrono, serde_json},不许 web 框架 / 业务包" fi # 第二层:源码不许出现业务包引用 local src="$CRATES/sspf-lowcode-exec/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 "AR13 执行层源码没有 use sspf_pack_*(业务知识没漏进执行层)" else bad "AR13 执行层源码出现了业务包引用(业务知识漏进平台层):" printf '%s\n' "$hits" | sed 's/^/ /' fi fi } # ---------------------------------------------------------------- AR14 # **MCP 适配层的依赖白名单**(M6 把 `mcp_{adapter,compat}.rs` 下沉到 `sspf-mcp-adapter`)。 # # 🔴 **为什么需要**:`sspf-mcp-adapter` 是**全仓唯一「知道全部包」的 crate** —— # `mcp_compat.rs` 直调 workflow / system / permission / onlinedev 四个契约面域包 # 的 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-onlinedev 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 } # ---------------------------------------------------------------- AR15 # **M7 删壳后:旧平台路径不许复活**(`crate::platform::…` / `ssw_platform::platform::…`)。 # # 🔴 **为什么需要**:M7 把 `src/backend/src/platform/` 的 38 个转发壳**全删了**, # 平台能力的路径变成 `sspf_core::…` / `sspf_compat_<包>::…`。 # 删除本身是**可逆的**(git 一 revert 就回来了)⇒ 必须有闸门钉住「不许回来」。 # # 🔴 **为什么这条不能靠「编译不过」兜底**:如果有人为了图省事 # ① 重建 `src/backend/src/platform/mod.rs` + 几个 `pub use` 壳, # ② 把 import 改回 `crate::platform::…`, # ⇒ **一切照常编译、测试照常全绿**,但架构**已经退回 M2 之前** —— # 而 M2–M7 这 7 个批次(几万行搬迁、6 个契约面包)的收益**全部蒸发**, # 而且**没有任何闸门会报红**。⇒ 这正是本仓最怕的那类静默退化。 # # 🔴 **判据**(源码级,全仓 Rust 文件): # ① 不许出现 `crate::platform::`(壳内引用旧路径); # ② 不许出现 `ssw_platform::platform::`(集成测试引用旧路径); # ③ 不许存在 `src/backend/src/platform/` 目录(M7 的删除不被回退)。 # # 🔴 **注释不算违规** —— 文档里提到旧路径是**正常**的(迁移记录 / 历史说明)。 # ⇒ 只判**非注释行**(与 AR10 同一套路)。 check_ar15() { local hits="" local roots=() [ -d "$KERNEL/src" ] && roots+=("$KERNEL/src") [ -d "$KERNEL/tests" ] && roots+=("$KERNEL/tests") [ -d "$CRATES" ] && roots+=("$CRATES") [ -d "$ROOT/packs" ] && roots+=("$ROOT/packs") if [ "${#roots[@]}" -gt 0 ]; then hits="$(python3 - "${roots[@]}" <<'PY' import os, re, sys pat = re.compile(r'(crate::platform::|ssw_platform::platform::)') bad = [] for root in sys.argv[1:]: for dirpath, dirnames, files in os.walk(root): for fn in files: if not fn.endswith('.rs'): continue p = os.path.join(dirpath, fn) try: lines = open(p, encoding='utf-8').read().splitlines() except OSError: continue for i, line in enumerate(lines, 1): s = line.strip() if s.startswith('//'): continue # 整行注释(含 //! / ///) code = line.split('//', 1)[0] if pat.search(code): bad.append(f'{p}:{i}: {s}') for b in bad: print(b) PY )" fi # 🔴 第三层:旧目录本身不许复活。 # ⚠️ **只看「含 .rs 文件」** —— git **不跟踪空目录** ⇒ 自证里 # `mkdir -p` 出来的空目录在清理后可能残留(rmdir 失败)⇒ # 若按「目录存在」判 ⇒ 假红(报了一个不存在的违规)。 # ⇒ 判据 = 「目录里**有** .rs 文件」= 真的有壳被重建了。 if [ -d "$KERNEL/src/platform" ]; then local plat_rs plat_rs="$(find "$KERNEL/src/platform" -name '*.rs' -type f 2>/dev/null | head -1)" if [ -n "$plat_rs" ]; then hits="${hits:+$hits$'\n'}$KERNEL/src/platform: 目录复活(M7 已删除该转发壳层,发现 ${plat_rs})" fi fi if [ -z "$hits" ]; then ok "AR15 旧平台路径未复活(无 crate::platform:: / ssw_platform::platform:: / platform/ 目录)" else bad "AR15 旧平台路径复活(M7 已删转发壳层 ⇒ 平台能力只能走 sspf_core:: / sspf_compat_*/::):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- PACK1 # **spec 单一真源**:`modules/.rs` 只许做转发,不许自己写 spec。 # # 🔴 背景:批次 12 之前 `modules/asset.rs` 与 `packs/asset/src/lib.rs` 是 # **两份逐字拷贝** ⇒ 改一处忘另一处 ⇒ **静默**不一致,且当时没有任何闸门比对。 # 现在 spec 的真源在包里,模块文件只 `pub use` 转发。 # ⇒ 本闸门要防的是「有人又在模块文件里写了一份」—— # 那等于回到两份拷贝,而且**看起来一切正常**(编译过、测试过)。 # # 判据(对每个「模块文件里有 `pub use sspf_pack_`」的模块): # · 模块文件里**不许**出现 `: EntitySpec =` / `: MenuSpec =` 的定义 # (`pub use` 转发不算定义 —— 它没有 `=` 字面量); # · 与它同 app_code 的包**必须存在**且**确实声明了** EntitySpec(否则转发了个空)。 check_pack1() { local n=0 for mf in "$MODULES_DIR"/*.rs; do [ -f "$mf" ] || continue case "$(basename "$mf")" in mod.rs) continue ;; esac grep -q "pub use sspf_pack_" "$mf" 2>/dev/null || continue n=$((n + 1)) local name; name="$(basename "$mf" .rs)" # ① 模块文件里不许有 spec / menu 的**定义**(`= EntitySpec {` / `= MenuSpec {`) local defs defs="$(grep -nE '=[[:space:]]*(EntitySpec|MenuSpec)[[:space:]]*\{' "$mf" 2>/dev/null || true)" if [ -n "$defs" ]; then bad "PACK1 ${name}.rs 既 re-export 又**自己定义**了 spec(两份拷贝回来了):" printf '%s\n' "$defs" | sed 's/^/ /' continue fi # ② 包必须存在,且真的声明了 EntitySpec local lib="$ROOT/packs/$name/src/lib.rs" if [ ! -f "$lib" ]; then bad "PACK1 ${name}.rs 从 sspf_pack_${name} 转发,但 packs/${name}/src/lib.rs 不存在" continue fi if ! grep -qE ':[[:space:]]*EntitySpec[[:space:]]*=' "$lib" 2>/dev/null; then bad "PACK1 packs/${name}/src/lib.rs 没有 EntitySpec 声明(模块转发了个空)" continue fi ok "PACK1 ${name}.rs 只做 re-export,spec 真源在 packs/${name}/src/lib.rs" done if [ "$n" -eq 0 ]; then # 🔴 2026-11-04 清理:没有业务模块可检查时**不能跳过**(假闸门)。 # 正向钉住「modules/ 只剩 mod.rs」;反自证 3/14 注入的临时模块仍会 # 在上面的循环里被抓到(它带 `pub use sspf_pack_` ⇒ n > 0)。 local stray stray="$(find "$MODULES_DIR" -maxdepth 1 -name '*.rs' ! -name 'mod.rs' -print 2>/dev/null)" if [ -n "$stray" ]; then bad "PACK1 平台包零业务:modules/ 出现业务适配器(应在业务仓):\n${stray}" else ok "PACK1 平台包零业务:modules/ 只剩 mod.rs(无 spec 两份拷贝的风险)" fi fi return 0 } # ---------------------------------------------------------------- MEM1 # 只看**代码行**:去掉 `//` 之后的注释、`//!` / `///` 文档注释、以及字符串里的反引号示例。 check_mem1() { local hits hits="$(python3 - "$ROOT" <<'PY' import os, re, sys root = sys.argv[1] pat = re.compile(r'SELECT\s+\*', re.I) bad = [] for base in ('src/backend/src', 'crates'): for dirpath, dirnames, files in os.walk(os.path.join(root, base)): dirnames[:] = [d for d in dirnames if d not in ('target', 'tests', 'data')] for fn in files: if not fn.endswith('.rs'): continue p = os.path.join(dirpath, fn) # 文件名以 _it.rs 结尾的是集成测试,不查 if fn.endswith('_it.rs'): continue try: lines = open(p, encoding='utf-8').read().splitlines() except OSError: continue in_test = False for i, line in enumerate(lines, 1): s = line.strip() if s.startswith('#[cfg(test)]'): in_test = True if in_test: continue code = line.split('//', 1)[0] if pat.search(code): bad.append(f'{p}:{i}: {s}') for b in bad: print(b) PY )" if [ -z "$hits" ]; then ok "MEM1 无非注释的 SELECT *(全表读进 Vec 会直接超内存预算)" else bad "MEM1 发现 SELECT *(终端产品内存预算 ≤120MB,禁止整表载入):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- MEM2 # 近似检查:出现 `Mutex/dev/null | head -1)" if [ -n "$binln" ]; then hits="src/backend/Cargo.toml:${binln%%:*}: 内核声明了 [[bin]](内核只能是 lib ⇒ 装配归 crates/sspf-admin)" fi fi # ⚠️ 只看「有 .rs 文件」:git 不跟踪空目录 ⇒ 空目录残留不算违规(与 AR15 同款)。 if [ -d "$KERNEL/tests" ]; then local trs trs="$(find "$KERNEL/tests" -name '*.rs' -type f 2>/dev/null | head -3)" if [ -n "$trs" ]; then hits="${hits:+$hits$'\n'}src/backend/tests: 集成测试回到了内核包(宿主是 crates/tests/tests/):$(printf '%s' "$trs" | tr '\n' ' ')" fi fi local admin="$CRATES/sspf-admin/Cargo.toml" if [ ! -f "$admin" ]; then hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 不存在(默认装配缺失 ⇒ 全仓没有可执行入口)" elif ! grep -qE '^\[\[bin\]\]' "$admin" 2>/dev/null; then hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 没有 [[bin]](默认装配必须产出可执行文件)" fi if [ -z "$hits" ]; then ok "AR16 内核只有 lib + 默认装配在 crates/sspf-admin + 集成测试在 crates/tests" else bad "AR16 内核/装配/测试的边界被打破:" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR17 # 🔴 **平台包零业务:依赖清单里不许有任何业务包 / 选装开关**(2026-11-04 清理)。 # # 原判据是「示例包依赖必须 optional + default 不开 example-packs」。清理后示例包、 # `example-packs` feature、`[features]` 段**全部退役** ⇒ 那条判据在空清单上恒真, # 反自证也没有探针可用(实测自证 12/14 直接红)。 # # 新判据(清单层面,秒级,不跑 cargo tree): # ① 内核 / 门面 / sspf-admin / sspf-tests / workspace 五个 Cargo.toml 的 # **非注释行**里不许出现 `sspf-pack-*` 依赖或 `example-packs` feature; # ② `src/backend/Cargo.toml` 的 `>>>GEN:PACK_DEPS` 标记段必须恒空; # ③ `packs/` 目录不许存在(与 AR2 互补,AR2 看依赖、这里看目录)。 # ⇒ 业务仓只依赖门面 `sspf`,通过 `Platform::packs()` 注入,不开任何平台 feature。 check_ar17() { local hits="" local toml="$KERNEL/Cargo.toml" [ -f "$toml" ] || { bad "AR17 内核 Cargo.toml 不存在"; return; } # ① 五个清单:跳过注释行(注释里讲「不许有 sspf-pack-*」是合法的) local f h for f in "$KERNEL/Cargo.toml" "$CRATES/sspf/Cargo.toml" \ "$CRATES/sspf-admin/Cargo.toml" "$CRATES/tests/Cargo.toml" "$ROOT/Cargo.toml"; do [ -f "$f" ] || continue h="$(awk '!/^[[:space:]]*#/ && /sspf-pack-|example-packs/ {print NR": "$0}' "$f" 2>/dev/null || true)" if [ -n "$h" ]; then hits="${hits:+$hits$'\n'}${f#$ROOT/}: 平台仓不许有业务包依赖 / example-packs feature:$'\n'$(printf '%s\n' "$h" | sed 's/^/ /')" fi done # ② 生成段恒空 local gen gen="$(awk '/>>>GEN:PACK_DEPS/{f=1;next} /<</dev/null || true)" if [ -n "$gen" ]; then hits="${hits:+$hits$'\n'}src/backend/Cargo.toml: >>>GEN:PACK_DEPS 段必须恒空,实际:$'\n'$(printf '%s\n' "$gen" | sed 's/^/ /')" fi # ③ packs/ 目录 if [ -d "$ROOT/packs" ]; then hits="${hits:+$hits$'\n'}平台仓出现 packs/ 目录 ⇒ 业务包请用 sspf::Platform::packs() 注入" fi if [ -z "$hits" ]; then ok "AR17 平台包零业务:5 个 Cargo.toml 无业务包依赖 / feature,GEN 段恒空,packs/ 不存在" else bad "AR17 平台包里混进了业务包(业务仓会被拖进示例包):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR18 # **门面 crate 不得出现任何业务字面量**(2026-11-04 标准平台包)。 # # 🔴 **为什么需要**:门面是「平台 ↔ 业务」的**唯一汇聚点** —— 它既认识平台的 19 个 # crate,又会被业务仓依赖。正因为它两边都碰得到,「顺手写一句业务」的成本极低: # `${业务表}_list` 的默认路由、`/api/ssw/...` 的示例端点、某个租户的写死分支…… # 这类代码**不会让任何测试变红**,但平台包就从「可复用」退化成「那一个业务的」。 # # 判据:`crates/sspf/src/**` 里**任何一行**(含注释)不得出现: # - 业务仓名 `tdc` # - 本仓 4 个示例包的表名(`asset_data_resource` / `demo_item` / # `shop_product` / `book_shop_book`) # - 面 A 的端点前缀 `/api/ssw/` # # 🔴 **注释也扫**(故意的):门面里出现业务名,读者就会以为平台认识它。 # 要写业务示例 ⇒ 写在 `docs/` 或业务仓自己那边。 check_ar18() { local dir="$CRATES/sspf/src" [ -d "$dir" ] || { skip "AR18 门面 crate 不存在(crates/sspf)"; return; } local hits hits="$(python3 - "$dir" <<'PY' import os, re, sys pat = re.compile(r'(?i)(tdc|asset_data_resource|demo_item|shop_product|book_shop_book|/api/ssw/)') bad = [] for root in sys.argv[1:]: for dirpath, _, files in os.walk(root): for fn in files: if not fn.endswith('.rs'): continue p = os.path.join(dirpath, fn) try: lines = open(p, encoding='utf-8').read().splitlines() except OSError: continue for i, line in enumerate(lines, 1): if pat.search(line): bad.append(f'{p}:{i}: {line.strip()}') for b in bad: print(b) PY )" if [ -z "$hits" ]; then ok "AR18 门面里没有业务字面量(无业务仓名 / 业务表名 / 面 A 端点)" else bad "AR18 门面里出现业务字面量(平台包退化成「那一个业务的」):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- AR19 # **唯一装配链**(2026-11-04 v0.3.0 两阶段装配)。 # # 🔴 **为什么需要**:业务自带状态的 `Router<()>` 现在能在 merge 点注入, # 「自己再抄一遍 fallback + layer + with_state」的诱惑变大了 —— 抄错顺序时 # axum 不报编译错,404 兜底只是悄悄失去 catch-all 保护,且**测试全绿**。 # # 判据(只看 `src/backend/src/routes.rs` 的**非注释**代码行): # - `pub fn build_app_with` 恰好 1 处; # - `.layer(catch_all())` 恰好 1 处; # - `.fallback(` / `.fallback_service(` 恰好 2 处(`if/else` 互斥分支 ⇒ 恒只有一个生效); # - `Extras.router_owned` 的文档注释必须含「不许自带 fallback」。 check_ar19() { local file="$KERNEL/src/routes.rs" [ -f "$file" ] || { skip "AR19 routes.rs 不存在"; return; } local hits hits="$(python3 - "$file" <<'PY' import re, sys lines = open(sys.argv[1], encoding='utf-8').read().splitlines() code = [(i, l) for i, l in enumerate(lines, 1) if not l.lstrip().startswith('//')] def hits(pat): return [(i, l) for i, l in code if re.search(pat, l)] bad = [] n = hits(r'pub fn build_app_with\b') if len(n) != 1: bad.append(f'unique-chain: pub fn build_app_with 应恰好 1 处,实际 {len(n)} 处') n = hits(r'\.layer\(catch_all\(\)\)') if len(n) != 1: bad.append(f'unique-catch-all: .layer(catch_all()) 应恰好 1 处,实际 {len(n)} 处') n = hits(r'\.fallback(_service)?\(') if len(n) != 2: bad.append(f'single-fallback: fallback 调用点应恰好 2 处(互斥分支),实际 {len(n)} 处') doc = '\n'.join(lines) m = re.search(r'((?:^\s*///.*\n)+)\s*pub router_owned:', doc, re.M) if not m or '不许自带 fallback' not in m.group(1): bad.append('router_owned-doc: Extras.router_owned 注释缺「不许自带 fallback」约定') for b in bad: print(b) PY )" if [ -z "$hits" ]; then ok "AR19 唯一装配链(build_app_with / catch_all / 单兜底 / 自带状态路由注释)" else bad "AR19 装配链被抄了第二遍(或兜底挂法退化):" printf '%s\n' "$hits" | sed 's/^/ /' fi } # ---------------------------------------------------------------- 反自证 # 🔴 永远返回「干净」的尺子 = 没有尺子。造明知违规的输入,必须被抓到。 self_test() { local rc=0 echo "── 反自证 1/14:造一个依赖越界的假 pack,AR2 必须报 ❌ ──" local tmp="$ROOT/packs/__arch_selftest__" mkdir -p "$tmp" cat > "$tmp/Cargo.toml" <<'TOML' [package] name = "arch-selftest" version = "0.0.0" edition = "2021" [dependencies] sspf-sdk = { path = "../../crates/sspf-sdk" } axum = "0.8" TOML local before=$FAIL check_ar2 >/dev/null 2>&1 local caught=0 [ "$FAIL" -gt "$before" ] && caught=1 rm -rf "$tmp" # 🔴 2026-11-04 清理:`mkdir -p packs/__arch_selftest__` 会把 `packs/` 一起造出来, # 只删子目录会留下**空 packs/** ⇒ AR2/AR17 的零业务判据当场红。 # ⇒ 用 rmdir(只删空目录,绝不动真文件)把探针外壳收干净。 rmdir "$ROOT/packs" 2>/dev/null || true FAIL=$before if [ "$caught" -eq 1 ]; then echo "✅ 反自证通过:AR2 抓到了 axum 依赖" else echo "❌ 反自证失败:AR2 没抓到明显违规 ⇒ 这把尺子是假的" rc=1 fi echo "── 反自证 2/14:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──" # # 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。 # 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。 # 这类尺子比没有更危险(它给出虚假的安全感)。 # 🔴🔴 **M7 起:平台层**只有真源**(`src/backend/src/platform/` 的 38 个转发壳已删) # ⇒ 注入点只剩真源一处。但**契约面各包也要注入**(AR9 扫的是整个 # `PLAT_SRC_DIRS`,含 `sspf-compat-*/src`)—— 只注入 core 不注入 compat # ⇒ 单点注入会漏判「闸门只扫 core 不扫 compat」⇒ **两处都注入**、 # 且**两处都被抓到**才算尺子有效。 local a9core="$CRATES/sspf-core/src/__ar9_selftest.rs" local a9compat="$CRATES/sspf-compat-system/src/__ar9_selftest.rs" local a9ok=0 if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then [ -d "$CRATES/sspf-core/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9core" [ -d "$CRATES/sspf-compat-system/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9compat" local a9out a9out="$(check_ar9 2>&1 || true)" rm -f "$a9core" "$a9compat" # 🔴 **按路径分别验**:必须证明闸门**两处都看得到** —— # 只验「输出里有 __ar9_selftest」不够(单处抓到会误判成两处都抓到)。 local a9need=0 a9c=0 if [ -d "$CRATES/sspf-core/src" ]; then a9need=$((a9need+1)) echo "$a9out" | grep -q "sspf-core/src/__ar9_selftest" && a9c=$((a9c+1)) fi if [ -d "$CRATES/sspf-compat-system/src" ]; then a9need=$((a9need+1)) echo "$a9out" | grep -q "sspf-compat-system/src/__ar9_selftest" && a9c=$((a9c+1)) fi [ "$a9need" -gt 0 ] && [ "$a9c" -ge "$a9need" ] && a9ok=1 fi if [ "$a9ok" -eq 1 ]; then echo "✅ 反自证通过:AR9 抓到了真源与契约面包里的 use sspf_pack_*" else echo "❌ 反自证失败:AR9 没抓到平台层里的业务包引用(或漏扫了真源/契约面)⇒ 尺子是假的" rc=1 fi echo "── 反自证 3/14:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──" # # 🔴 造在**临时模块文件**上(不动真文件):只要它同时有 `pub use sspf_pack_` # 和 `= EntitySpec {`,PACK1 就必须红。 local mprobe="$MODULES_DIR/__pack1_selftest.rs" if [ -d "$MODULES_DIR" ]; then cat > "$mprobe" <<'RS' pub use sspf_pack_asset::DATA_RESOURCE_SPEC; pub const DUP_SPEC: EntitySpec = EntitySpec { entity: "Dup", table: "dup", .. }; RS before=$FAIL check_pack1 >/dev/null 2>&1 caught=0 [ "$FAIL" -gt "$before" ] && caught=1 rm -f "$mprobe" FAIL=$before if [ "$caught" -eq 1 ]; then echo "✅ 反自证通过:PACK1 抓到了「既 re-export 又自己定义 spec」" else echo "❌ 反自证失败:PACK1 没抓到两份拷贝 ⇒ 尺子是假的" rc=1 fi else echo "⏭ 跳过 PACK1 反自证(业务模块目录不存在)" fi echo "── 反自证 4/14:往 sspf-plugin 塞 axum 依赖,AR8 必须报 ❌ ──" local pfile="$CRATES/sspf-plugin/Cargo.toml" if [ -f "$pfile" ]; then cp "$pfile" "$pfile.bak" printf 'axum = "0.8"\n' >> "$pfile" before=$FAIL check_ar8 >/dev/null 2>&1 caught=0 [ "$FAIL" -gt "$before" ] && caught=1 mv "$pfile.bak" "$pfile" FAIL=$before if [ "$caught" -eq 1 ]; then echo "✅ 反自证通过:AR8 抓到了装载器里的 axum 依赖" else echo "❌ 反自证失败:AR8 没抓到装载器里的 axum ⇒ 尺子是假的" rc=1 fi else echo "⏭ 跳过 AR8 反自证(sspf-plugin 不存在)" fi echo "── 反自证 5/14:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──" # # 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。 # 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。 # 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,后续批次才炸。 # 🔴🔴 **M7 起注入两处**(平台核心真源 + 契约面真源),与 2/6 同理:单点注入会漏判。 # ⚠️ 契约面**自己**引用 `compat::` 是合法的(面 B 内部互引)⇒ AR10 的 # Python 扫描会跳过名为 `compat` 的子目录 —— 但现在契约面在**独立 crate**里 # ⇒ 目录里**没有** `compat` 子目录 ⇒ 注入到 `sspf-compat-system/src/` 会被抓到。 local a10core="$CRATES/sspf-core/src/__ar10_selftest.rs" local a10compat="$CRATES/sspf-compat-system/src/__ar10_selftest.rs" local a10ok=0 if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then [ -d "$CRATES/sspf-core/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10core" [ -d "$CRATES/sspf-compat-system/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10compat" local a10out a10out="$(check_ar10 2>&1 || true)" rm -f "$a10core" "$a10compat" local a10need=0 a10c=0 if [ -d "$CRATES/sspf-core/src" ]; then a10need=$((a10need+1)) echo "$a10out" | grep -q "sspf-core/src/__ar10_selftest" && a10c=$((a10c+1)) fi if [ -d "$CRATES/sspf-compat-system/src" ]; then a10need=$((a10need+1)) echo "$a10out" | grep -q "sspf-compat-system/src/__ar10_selftest" && a10c=$((a10c+1)) fi [ "$a10need" -gt 0 ] && [ "$a10c" -ge "$a10need" ] && a10ok=1 fi if [ "$a10ok" -eq 1 ]; then echo "✅ 反自证通过:AR10 抓到了真源里的 crate::platform::compat" else echo "❌ 反自证失败:AR10 没抓到平台层的契约面反向依赖(或漏扫了真源)⇒ 尺子是假的" rc=1 fi echo "── 反自证 6/14:往契约面底座塞 use super::system,AR11 必须报 ❌ ──" # # 🔴🔴 **M7 起底座只有一处**:真源 `crates/sspf-compat-core/src/helper.rs` # (转发壳 `src/backend/src/platform/compat/helper.rs` 已随 M7 删除)。 # ⇒ 注入点只剩真源一处。 # 做法:备份真文件 → 追加违规行 → 跑判据 → 还原(helper.rs 是活文件)。 local a11ok=0 local a11core="$CRATES/sspf-compat-core/src/helper.rs" local a11need=0 a11c=0 a11out if [ -f "$a11core" ]; then cp "$a11core" "$a11core.bak" && printf '\nuse super::system::menu_node;\n' >> "$a11core" && a11need=$((a11need+1)) a11out="$(check_ar11 2>&1 || true)" [ -f "$a11core.bak" ] && mv "$a11core.bak" "$a11core" [ -f "$a11core" ] && { echo "$a11out" | grep -q "sspf-compat-core/src/helper.rs" && a11c=$((a11c+1)); } [ "$a11need" -gt 0 ] && [ "$a11c" -ge "$a11need" ] && a11ok=1 fi if [ "$a11ok" -eq 1 ]; then echo "✅ 反自证通过:AR11 抓到了底座真源里的 use super::system" else echo "❌ 反自证失败:AR11 没抓到底座的反向依赖(或漏扫了真源)⇒ 尺子是假的" rc=1 fi echo "── 反自证 7/14:往壳里写 crate::platform::,AR15 必须报 ❌ ──" # # 🔴 **必须自证 AR15**:删掉 `platform/` 转发壳之后,旧路径就**没有编译器**兜底了 # —— 只要有人重建壳目录并把 import 改回去,**一切照常编译、测试照常全绿**, # 而 M2–M7 的架构收益全部蒸发。⇒ 必须有一条闸门钉住「不许回来」。 # 🔴 **注入三处**(证明三层判据都有效): # ① 壳内引用旧路径(`crate::platform::`)⇒ 源码级判据要抓到; # ② 集成测试引用旧路径(`ssw_platform::platform::`)⇒ 同上; # ③ 重建 `src/backend/src/platform/` 目录 ⇒ 目录级判据要抓到。 local a15ok=0 local a15probe="$KERNEL/src/__ar15_selftest.rs" # 🔴 **2026-11-04 起集成测试宿主在 `crates/tests/tests/`**(AR16)—— # 探针必须打在**真在扫描面里**的目录上:AR15 的 roots 含 `$CRATES`, # 所以打到 `crates/tests/tests/` 才证明「测试里的旧路径也被抓」。 local a15testdir="$ROOT/crates/tests/tests" local a15test="$a15testdir/__ar15_selftest.rs" local a15dir="$KERNEL/src/platform" local a15had_dir=0 [ -d "$a15dir" ] && a15had_dir=1 printf 'use crate::platform::sys::user_list;\n' > "$a15probe" [ -d "$a15testdir" ] && printf 'use ssw_platform::platform::db::Db;\n' > "$a15test" mkdir -p "$a15dir" printf '//! 探针\n' > "$a15dir/__ar15_selftest.rs" local a15out a15out="$(check_ar15 2>&1 || true)" rm -f "$a15probe" "$a15test" "$a15dir/__ar15_selftest.rs" # 🔴 **清理要彻底**:删探针文件 + 删目录(git 不跟踪空目录 ⇒ 残留会让下次 # 主检查**假红** —— 实测踩过:`rmdir` 失败后留下空目录)。 rm -rf "$a15dir" [ "$a15had_dir" -eq 1 ] && mkdir -p "$a15dir" # 🔴 **按判据分别验**:三处都必须被提到(只看「输出非空」不够)。 local a15c=0 echo "$a15out" | grep -q "__ar15_selftest.rs" && a15c=$((a15c+1)) echo "$a15out" | grep -q "platform: 目录复活" && a15c=$((a15c+1)) [ "$a15c" -ge 2 ] && a15ok=1 if [ "$a15ok" -eq 1 ]; then echo "✅ 反自证通过:AR15 抓到了旧路径引用与 platform/ 目录复活" else echo "❌ 反自证失败:AR15 没抓到旧平台路径复活(源码级 / 目录级判据可能失效)⇒ 尺子是假的" rc=1 fi echo "── 反自证 8/14:给域包塞一条未授权的跨包依赖,AR12 必须报 ❌ ──" # # 🔴 **为什么必须自证 AR12**:它的判据是「读 Cargo.toml 找 sspf-compat-* 依赖」。 # 若 grep 模式写错(包名含连字符/下划线混用)⇒ 永远扫不到依赖 ⇒ # **永远"通过"** ⇒ 虚假安全感。而 AR12 守的正是「契约面各包不会成环」。 # 🔴 **注入必须避开白名单**:挑 `sspf-compat-msg`(它不在任何白名单里, # 反向依赖 `sspf-compat-workflow` ⇒ 立刻成环)⇒ 必须被抓到。 local a12ok=0 local a12toml="$CRATES/sspf-compat-msg/Cargo.toml" if [ -f "$a12toml" ]; then cp "$a12toml" "$a12toml.bak" printf '\nsspf-compat-workflow = { path = "../sspf-compat-workflow" }\n' >> "$a12toml" local a12out a12out="$(check_ar12 2>&1 || true)" mv "$a12toml.bak" "$a12toml" # 🔴 必须**按路径验**:输出里要明确出现被注入的那个包 + 那个依赖 if echo "$a12out" | grep -q "sspf-compat-msg → sspf-compat-workflow"; then a12ok=1 fi fi if [ "$a12ok" -eq 1 ]; then echo "✅ 反自证通过:AR12 抓到了 msg → workflow 的未授权跨包依赖" else echo "❌ 反自证失败:AR12 没抓到未授权的跨包依赖 ⇒ 尺子是假的" rc=1 fi echo "── 反自证 9/14:给执行层塞一个越界依赖 + 一条业务包引用,AR13 必须报 ❌ ──" # # 🔴 **必须自证 AR13**:它的判据是「读 Cargo.toml + grep 源码」。 # 两种失效模式都得堵: # ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(执行层拖进 web 框架 ⇒ CLI/MCP 报废); # ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(平台层开始认识业务 ⇒ 破 AR9)。 # 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。 local a13ok=0 local a13toml="$CRATES/sspf-lowcode-exec/Cargo.toml" local a13src="$CRATES/sspf-lowcode-exec/src/__ar13_selftest.rs" local a13need=0 a13c=0 a13out if [ -f "$a13toml" ]; then cp "$a13toml" "$a13toml.bak" printf '\naxum = { workspace = true }\n' >> "$a13toml" a13need=$((a13need+1)) printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a13src" a13need=$((a13need+1)) a13out="$(check_ar13 2>&1 || true)" [ -f "$a13toml.bak" ] && mv "$a13toml.bak" "$a13toml" rm -f "$a13src" # ① 越界依赖(axum)必须被依赖白名单抓到 echo "$a13out" | grep -q "依赖越界" && a13c=$((a13c+1)) # ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出") echo "$a13out" | grep -q "sspf-lowcode-exec/src/__ar13_selftest" && a13c=$((a13c+1)) [ "$a13need" -gt 0 ] && [ "$a13c" -ge "$a13need" ] && a13ok=1 fi if [ "$a13ok" -eq 1 ]; then echo "✅ 反自证通过:AR13 抓到了越界依赖(axum)与执行层里的业务包引用" else echo "❌ 反自证失败:AR13 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的" rc=1 fi echo "── 反自证 10/14:给适配层塞一个越界依赖 + 一条业务包引用,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 echo "── 反自证 11/14:内核加回 [[bin]] + 塞回 tests/*.rs,AR16 必须两处都报 ❌ ──" # # 🔴 **必须自证 AR16**:它的三条判据全是「文件/目录在不在」—— # 路径写错(比如把 $KERNEL 拼成别的名字)⇒ 永远判「没问题」⇒ # 结构会静默退回到 2026-11-04 之前的样子(内核自带 bin、测试挂内核包)。 # ⇒ 两处都注入、两处都被抓到才算尺子有效。 local a16ok=0 local a16toml="$KERNEL/Cargo.toml" local a16dir="$KERNEL/tests" local a16need=0 a16c=0 a16before a16out="" if [ -f "$a16toml" ]; then a16before=$FAIL cp "$a16toml" "$a16toml.bak" printf '\n[[bin]]\nname = "__ar16_selftest"\npath = "src/lib.rs"\n' >> "$a16toml" a16need=$((a16need + 1)) mkdir -p "$a16dir" printf '// AR16 自证用,跑完即删\n' > "$a16dir/__ar16_selftest.rs" a16need=$((a16need + 1)) a16out="$(check_ar16 2>&1 || true)" [ -f "$a16toml.bak" ] && mv "$a16toml.bak" "$a16toml" rm -f "$a16dir/__ar16_selftest.rs" rmdir "$a16dir" 2>/dev/null || true FAIL=$a16before echo "$a16out" | grep -qF '内核声明了 [[bin]]' && a16c=$((a16c + 1)) echo "$a16out" | grep -qF '集成测试回到了内核包' && a16c=$((a16c + 1)) [ "$a16need" -gt 0 ] && [ "$a16c" -ge "$a16need" ] && a16ok=1 fi if [ "$a16ok" -eq 1 ]; then echo "✅ 反自证通过:AR16 抓到了内核里的 [[bin]] 与回流的 tests/*.rs" else echo "❌ 反自证失败:AR16 没抓到内核 [[bin]] / 回流的 tests(或漏判了其中一处)⇒ 尺子是假的" rc=1 fi echo "── 反自证 12/14:往内核塞回一条 sspf-pack 依赖,AR17 必须报 ❌ ──" # # 🔴 **2026-11-04 清理**:依赖清单里已经没有 pack 行可改 ⇒ 旧探针(去掉 # `optional = true`)找不到锚点,自证会**假红**。改成「注入一整条硬依赖」, # 判据仍是「AR17 对业务包依赖敏感」,锚点不再依赖示例包是否存在。 local a17toml="$KERNEL/Cargo.toml" local a17ok=0 if [ -f "$a17toml" ]; then cp "$a17toml" "$a17toml.ar17bak" printf '\nsspf-pack-probe = { path = "../../packs/probe" }\n' >> "$a17toml" local a17before=$FAIL check_ar17 >/dev/null 2>&1 local a17caught=0 [ "$FAIL" -gt "$a17before" ] && a17caught=1 mv "$a17toml.ar17bak" "$a17toml" FAIL=$a17before [ "$a17caught" -eq 1 ] && a17ok=1 fi if [ "$a17ok" -eq 1 ]; then echo "✅ 反自证通过:AR17 抓到了回流的 sspf-pack 依赖" else echo "❌ 反自证失败:AR17 没抓到回流的业务包依赖 ⇒ 尺子是假的" rc=1 fi echo "── 反自证 13/14:往门面里塞一句业务字面量,AR18 必须报 ❌ ──" # # 🔴 **为什么自证 AR18**:它扫的是「门面源码里的业务名」。目录写错 / 正则写错 # ⇒ 永远空 ⇒ 永远"通过"。这条自证保证「平台包里零业务」不是一句口号。 local a18dir="$CRATES/sspf/src" local a18ok=0 if [ -d "$a18dir" ]; then printf 'pub const AR18_SELFTEST: &str = "tdc_order";\n' > "$a18dir/__ar18_selftest.rs" local a18before=$FAIL check_ar18 >/dev/null 2>&1 local a18caught=0 [ "$FAIL" -gt "$a18before" ] && a18caught=1 rm -f "$a18dir/__ar18_selftest.rs" FAIL=$a18before [ "$a18caught" -eq 1 ] && a18ok=1 fi if [ "$a18ok" -eq 1 ]; then echo "✅ 反自证通过:AR18 抓到了门面里的业务表名" else echo "❌ 反自证失败:AR18 没抓到门面里的业务字面量 ⇒ 尺子是假的" rc=1 fi echo "── 反自证 14/14:往 routes.rs 塞第二处 .layer(catch_all()),AR19 必须报 ❌ ──" # # 🔴 **为什么自证 AR19**:它数的是「非注释代码里 catch_all 层的条数」。 # 正则写错 / 扫描面写错 ⇒ 永远数到 1 ⇒ 永远"通过"。 local a19file="$KERNEL/src/routes.rs" local a19ok=0 if [ -f "$a19file" ]; then cp "$a19file" "$a19file.ar19bak" printf '\nfn __ar19_selftest() { let _ = axum::Router::new().layer(catch_all()); }\n' >> "$a19file" local a19before=$FAIL check_ar19 >/dev/null 2>&1 local a19caught=0 [ "$FAIL" -gt "$a19before" ] && a19caught=1 mv "$a19file.ar19bak" "$a19file" FAIL=$a19before [ "$a19caught" -eq 1 ] && a19ok=1 fi if [ "$a19ok" -eq 1 ]; then echo "✅ 反自证通过:AR19 抓到了第二处 catch_all 层" else echo "❌ 反自证失败:AR19 没抓到重复的装配链层 ⇒ 尺子是假的" rc=1 fi return $rc } # ---------------------------------------------------------------- main [ "${1:-}" = "--help" ] && { usage; exit 0; } echo "── 架构边界闸门(crate 依赖纪律 + 内存红线)──" check_ar1 check_ar2 check_ar3 check_ar4 check_ar5 check_ar6 check_ar7 check_ar8 check_ar9 check_ar10 check_ar11 check_ar12 check_ar13 check_ar14 check_ar15 check_ar16 check_ar17 check_ar18 check_ar19 check_pack1 check_mem1 check_mem2 echo printf '结果: %d 通过 / %d 失败 / %d 跳过\n' "$PASS" "$FAIL" "$SKIP" if [ "${1:-}" = "--self-test" ]; then echo self_test || exit 1 fi [ "$FAIL" -eq 0 ] || exit 1 exit 0