Files
adminandClaude Code d14440a3ed feat(server): v1.8.0 本体导入 + 分区 + 行级归属 + 认证位 + 结构 diff + 分页 + 进度回报
一次收口 2026-11-06 的九项能力(CHANGELOG 1.5.4 → 1.8.0):

- 自检探针(readiness.go):check_readiness / check_answerable 两个只读探针,把
  「本体里没有」「我没权限看」「模型没抽全」三种空结果原因拆开
- 读路径语义钉死(scope.go):标记与分级的可见范围统一由 Scope 产出,实例分级
  为空时继承类型默认级(fail-closed),列表与详情口径一致
- 行级可改性轴(object_owner.go):归属只收窄不宽于 grants,所有对象写路径统一
  走 canWriteObject,归属查询失败即拒绝
- 公理第 6 类 certification:认证位保护人工策展内容,AI 重摄取不再覆盖已认证条目
- 跨版本结构 diff(schema_diff.go):schema_snapshots 全量快照 + diff 端点,机器
  事实与人工策展分组呈现
- 分区维度 zone:分区绑类型、命中任一即可见,读路径一律带 zone 条件
- 统一分页信封(pagination.go):列表回包统一 count/total/limit/offset/has_more/
  truncated,total 与 items 同源
- MCP 长任务进度(mcp_progress.go):客户端带 progressToken 才走 SSE 进度帧
- 本体 schema 导入(ontology_import.go):Turtle 导入 + 四道 fail-fast 闸门 +
  整事务 + (source, external_id) 幂等 + IRI 往返不变式

MCP 工具清单并入单一注册表(mcp_registry.go),对外声明与实际可调不再各说各话;
工具数 42 → 54(只读 27 / 写入 27),注册表与分发 case 的双向漂移由 AST 单测拦截。

CHANGELOG 编号整理:新「认证位 + 行级归属」条目由 1.6.0 改为 1.5.6(1.6.x 留给
分区与结构 diff),2026-09-20 的 GB/T 规划稿改标「规划稿·未发布」——该能力已并入
v1.5.1,避免与正式发布的版本号重复。

Co-Authored-By: Claude Code <[email protected]>
2026-11-06 13:51:48 +08:00

236 lines
7.3 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package main
// 行级可改性轴(object_owners):谁可以改这一行。
//
// 与 clearance(可见性轴)正交,两轴各管一件事:
//
// clearance / marking —— 「看不看得到」 (object_markings + principal_clearances)
// owner —— 「能不能改」 (object_owners)
//
// 判定口径(刻意不与 grants 重叠):
//
// - grants 表是「能做什么动作」的唯一真源(read/write/delete/apply…);
// - owner 是在 grant 之上的一层**收窄**:对象设有归属时,非归属方即便持有该类型的
// 写授权,也不能改这一行;
// - 对象**未设归属**(无 owner 行)→ 不收窄,历史行为一字不变(向后兼容);
// - manager 不受归属限制(与 CanRead / CanWrite 的 manager 豁免一致);
// - 组归属:组成员获得该行的可改性,**且仅限该行**——不扩大任何全局权限。
//
// 「归属只收窄、不放宽」是刻意的:若归属本身就能授予写权限,那么「谁拥有写权限」
// 就散落在 grants 表之外,Access Control 界面看到的授权清单将不等于实际权限。
// 归属的职责是回答「这一行归谁管」,不是回答「谁能写」。
import (
"context"
"fmt"
"sort"
"strings"
)
// 归属种类。
const (
OwnerKindPrincipal = "principal" // 主体(账号)
OwnerKindGroup = "group" // 组
)
// ObjectOwner 归属条目:某行的归属方。
type ObjectOwner struct {
Kind string `json:"kind"` // principal | group
Name string `json:"name"`
}
// loadObjectOwners 取某对象的归属集合(无归属返回空切片,非 nil)。
func (a *app) loadObjectOwners(ctx context.Context, objType, objPK string) ([]ObjectOwner, error) {
rows, err := a.pool.Query(ctx,
`SELECT owner_kind, owner_name FROM object_owners
WHERE object_type=$1 AND object_pk=$2 ORDER BY owner_kind, owner_name`, objType, objPK)
if err != nil {
return nil, err
}
defer rows.Close()
out := []ObjectOwner{}
for rows.Next() {
var o ObjectOwner
if err := rows.Scan(&o.Kind, &o.Name); err == nil {
out = append(out, o)
}
}
return out, rows.Err()
}
// principalGroupNames 取某主体所属的全部组。
func (a *app) principalGroupNames(ctx context.Context, principal string) (map[string]bool, error) {
out := map[string]bool{}
if principal == "" {
return out, nil
}
rows, err := a.pool.Query(ctx, `SELECT group_name FROM principal_groups WHERE principal=$1`, principal)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var g string
if err := rows.Scan(&g); err == nil {
out[g] = true
}
}
return out, rows.Err()
}
// ownerDecision 归属判定(纯函数,不触库,便于单测)。
//
// 返回 (isOwner, hasOwners):
// - hasOwners=false:该行未设归属 → 不限制任何人(isOwner 恒为 true);
// - hasOwners=true:只有归属方(本人或所属组)才是 owner。
func ownerDecision(owners []ObjectOwner, principal string, groups map[string]bool) (isOwner bool, hasOwners bool) {
if len(owners) == 0 {
return true, false
}
for _, o := range owners {
switch o.Kind {
case OwnerKindPrincipal:
if o.Name == principal {
return true, true
}
case OwnerKindGroup:
if groups[o.Name] {
return true, true
}
}
}
return false, true
}
// principalOwnsObject 判定 principal 是否持有该行的可改性。
func (a *app) principalOwnsObject(ctx context.Context, principal, objType, objPK string) (bool, bool, error) {
owners, err := a.loadObjectOwners(ctx, objType, objPK)
if err != nil {
return false, true, err
}
if len(owners) == 0 {
return true, false, nil
}
groups, err := a.principalGroupNames(ctx, principal)
if err != nil {
return false, true, err
}
isOwner, hasOwners := ownerDecision(owners, principal, groups)
return isOwner, hasOwners, nil
}
// canWriteObject 写权限判定 = grant 授权 ∧ 行级归属允许。
//
// 这是**唯一的写权限收敛点**:所有对象写路径(create/update/delete/restore/
// batch/action/链接)都改走本函数,不各自散落判据。
//
// fail-closed:归属查询失败 → 拒绝(读不到归属 ≠ 可以改)。
// manager 豁免归属(与 CanWrite/CanRead 的 manager 特例一致)。
func (a *app) canWriteObject(ctx context.Context, authz *Authz, action, objType, objPK string) bool {
if authz == nil {
return false
}
if authz.Principal == "manager" {
return true
}
if !authz.CanWrite(action, objType, objPK) {
return false
}
isOwner, _, err := a.principalOwnsObject(ctx, authz.Principal, objType, objPK)
if err != nil {
return false
}
return isOwner
}
// normalizeOwners 校验并归一化归属条目:种类合法、去重、保序。
// 空名单合法(= 清空归属)。
func normalizeOwners(in []ObjectOwner) ([]ObjectOwner, error) {
out := []ObjectOwner{}
seen := map[string]bool{}
for _, o := range in {
kind := strings.TrimSpace(o.Kind)
if kind == "" {
kind = OwnerKindPrincipal
}
if kind != OwnerKindPrincipal && kind != OwnerKindGroup {
return nil, fmt.Errorf("owner.kind 只支持 principal 或 group,收到 %q", o.Kind)
}
name := strings.TrimSpace(o.Name)
if name == "" {
return nil, fmt.Errorf("owner.name 必填")
}
k := kind + "|" + name
if seen[k] {
continue
}
seen[k] = true
out = append(out, ObjectOwner{Kind: kind, Name: name})
}
return out, nil
}
// ownerWritableAdvisory 检查归属方当前是否真的持有写授权,
// 返回「其实改不动」的归属方名单(纯提示,不阻断赋值)。
//
// 归属只收窄不放宽,所以一个没有 write 授权的归属方拿到行也改不动——
// 这在「先设归属、后发授权」的编排下很常见,因此只提示不拒绝。
func (a *app) ownerWritableAdvisory(ctx context.Context, owners []ObjectOwner, objType, objPK string) []string {
var blind []string
for _, o := range owners {
switch o.Kind {
case OwnerKindPrincipal:
if !a.principalCanWrite(ctx, o.Name, objType, objPK) {
blind = append(blind, o.Name)
}
case OwnerKindGroup:
members, err := a.groupMembers(ctx, o.Name)
if err != nil || len(members) == 0 {
blind = append(blind, o.Name+"(组内无成员或查询失败)")
continue
}
any := false
for _, m := range members {
if a.principalCanWrite(ctx, m, objType, objPK) {
any = true
break
}
}
if !any {
blind = append(blind, o.Name+"(组内无成员持有写授权)")
}
}
}
sort.Strings(blind)
return blind
}
// principalCanWrite 查某主体是否持有对该对象的写授权(不含归属判定)。
func (a *app) principalCanWrite(ctx context.Context, principal, objType, objPK string) bool {
if principal == "manager" {
return true
}
az, err := a.loadAuthz(ctx, principal, true)
if err != nil || az == nil {
return false
}
return az.CanWrite("write", objType, objPK)
}
// groupMembers 取某组成员(有序)。
func (a *app) groupMembers(ctx context.Context, group string) ([]string, error) {
rows, err := a.pool.Query(ctx, `SELECT principal FROM principal_groups WHERE group_name=$1 ORDER BY principal`, group)
if err != nil {
return nil, err
}
defer rows.Close()
out := []string{}
for rows.Next() {
var p string
if err := rows.Scan(&p); err == nil {
out = append(out, p)
}
}
return out, rows.Err()
}