6 Commits
Author SHA1 Message Date
admin 15d0893522 docs(changelog): v1.3.6 发布说明([Unreleased] 定版 issue #8 MCP 读路径真实身份) 2026-09-07 18:41:14 +08:00
admin 6841712289 fix(mcp): 读路径透传调用方真实身份(issue #8 v2)
按用户反馈「每个主体都有 mcp 访问 key,就应该是各自主体身份」——
v1 方案「注入 connector key + 手动 X-Principal」本质是「模拟身份」,
绕开了主体解析链。v2 改为透传调用方真实鉴权。

### 改动
- callConn 接受源 *gin.Context,透传 X-API-Key / session cookie 给内层请求,
  让 principalFromRequest 自然解析到 manager / connector / analyst / 等。
- connectorAuth 放宽到「任一主体 api_key 即放行」:
  - 移除 WHERE name='connector' 的硬约束
  - 助手 anyPrincipalKeySet() 判断全库是否已有密钥(有则要求带 key,无则放行兼容无密钥只读)
- 6 个调用点去掉 principal 参数,改传 c。

### 影响
- 之前:MCP 读工具一律以 connector 执行,manager 走 MCP 只能看 L0-L2。
- 现在:各主体按自己 clearance 视图读,manager 走 MCP 见全部分级(含 L3)。
- callConn 路径与 connectorAuth 路径身份解析统一(都走 principalFromRequest 自然解析)。

### 验证
- 3 个新集成测试全绿(issue8_mcp_read_principal_test.go):
  按 connector / manager / analyst 三种 api_key 调 MCP get_objects_by_type,
  分别见 2 / 3 / 1 条(符合各自 clearance)。
- 既有 issue #6/#7 的 6 个测试 + SetObjectTypeClassification 全绿。

### CHANGELOG 风格
按用户反馈「只有改了什么 / 有什么影响,不要流水账」,
重写 [Unreleased] / [1.3.3] / [1.3.2] 三段:每段只留「影响 + 改动 [+ 设计]」,
去掉过程叙述、commit hash、调试日志、issue 评论引用等。
2026-09-07 18:36:21 +08:00
admin 2a58d5adab docs(changelog): v1.3.3 发布说明([Unreleased] 定版 issue #7 clearance 配置) 2026-09-07 17:43:46 +08:00
admin 8388e14772 feat(access): 补 principal clearance 配置入口(采纳 issue #7)
用户报告「principal_clearances 不可配置,导致 L3 实例对所有非 manager 主体不可见」
—— 实测是 UX 缺口:

### 修复
- PUT /access/principals/:name 的 principalUpdateInput 新增 clearances 字段(nil=不动;
  非空数组(含 [])= 全量替换),与 PUT /principals/:name/clearances 同义。
- GET /access/principals/:name 响应新增 clearances 数组(保证非 nil,空集序列化为 [])。
- GET /access/principals 列表也回显 clearances,避免管理员看不到当前状态。

### 新增 MCP 工具(之前 36 个没有这一片)
- list_principals:列出全部主体及其 clearance。
- get_principal:按名取单个主体(含 description / has_api_key / clearances)。
- set_principal_clearance:全量替换主体 clearance(alias 接受 markings / clearances)。

### 不动的部分
- seedAccessControlDefaults 中 manager 默认 [L0,L1,L2,L3,L4] 已正确(CHANGELOG v1.2.0
  「manager 不受影响」依然成立)。
- classificationCond / classAllowed 对 manager 显式放行已正确;用户报告的「admin
  看不到 L3」实际是误读——真正不可见的是非 manager 主体(默认 connector L0-L2、public L0)。

### 验证
- 新增 3 个集成测试(issue7_clearance_config_test.go):
  updatePrincipal clearances / MCP 端到端 / 旧专用端点回归,全绿。
- 既有测试除 TestIntegration_ClassificationFilter 外全绿(后者预存在失败)。
2026-09-07 17:38:54 +08:00
admin 938a5fc960 docs(changelog): v1.3.2 发布说明([Unreleased] 定版 issue #6 本体属性注册修复) 2026-09-07 16:53:14 +08:00
admin c16957b97d feat(ontology): 补 update_object_type / add_object_type_property(采纳 issue #6 方案 A+B)
用户提交 issue #6 反映「587 个 data_level 实例是孤儿,原生分级引擎无法接管」
(分类引擎要求 classification_property 必须在 schema 中注册,但无任何端点
能把属性注册到已存在类型上)。

### 修复
- PUT /api/v1/ontology/object-types/:name 此前静默忽略 properties 字段
  (用户实测加 zz_probe 属性再 GET 没注册上)。现 objectTypeInput 新增
  properties 数组字段,非空时由 upsertObjectTypeProperties 一并 upsert
  (同名更新元数据,新名新增)。createObjectType 也同步支持内联 properties,
  两条路径共用同一辅助函数,语义一致。

### 新增 MCP 工具
- update_object_type(包装 PUT /object-types/:name):更新 display/icon/group/
  分级三件套同时可批量 upsert properties。
- add_object_type_property(包装 POST /object-types/:name/properties):
  细粒度「加一个属性」入口,适合只补一个属性的场景(如分级属性 data_level)。

### 不采纳
- 方案 C(让 set_object_type_classification 在 property 不存在时自动注入):
  把属性注册藏在分类配置里语义混淆,属性注册应是显式动作 + 可独立审计。

### 验证
- 新增 3 个集成测试(issue6_object_type_property_test.go):
  update_object_type merge / add_object_type_property MCP 端到端 /
  update_object_type MCP 端到端,全绿。
- 全部既有测试除 TestIntegration_ClassificationFilter 外全绿;后者为预存在
  失败(stash 本次改动后仍 fail,根因不在本 PR 范围内)。
2026-09-07 16:41:52 +08:00
9 changed files with 1174 additions and 27 deletions

No files matched your search

+29
View File
@@ -18,6 +18,35 @@ AI 客户端在使用本平台过程中发现 bug 或有改进建议,**请提
## 版本历史
## [1.3.6] - 2026-09-07 MCP 读路径按真实调用者解析主体(issue #8)
**影响**:MCP 读工具(get_objects_by_type / get_object / query_related / search_ontology / get_object_types / get_facets)此前一律以 connector 主体执行,manager 走 MCP 只能看 connector clearance (L0-L2) 下的数据;现已按调用者真实 api_key 解析主体。
**改动**:
- `callConn` 改为透传调用方 `X-API-Key` / session cookie,让 `principalFromRequest` 自然解析主体;不再注入 connector key + 手动 X-Principal(之前是「模拟身份」)。
- `connectorAuth` 放宽:接受任何主体的 api_key(不再只接 connector key)。连接器入口 = 任何已认证主体;可见性仍由读路径 classification filter 按各自 clearance 控制。
**顺带**:`PUT /access/principals/:name` 只传 description 时响应 `has_api_key` 误报 false 已修复(读取 DB 真实状态回显)。
## [1.3.3] - 2026-09-07 访问控制:principal clearance 可配置(issue #7)
**影响**:之前管理员无法通过 `PUT /principals/:name` 配置 clearance(字段被静默忽略),主体 clearance 列表接口也不回显;现已补齐。
**改动**:
- `PUT /access/principals/:name` 新增 `clearances []string`(nil=不动;非空=全量替换)。
- `GET /principals/:name` 与列表回显 `clearances`(保证非 nil)。
- MCP 新增 `list_principals` / `get_principal` / `set_principal_clearance` 三个工具。
## [1.3.2] - 2026-09-07 本体:补 update_object_type / add_object_type_property(issue #6)
**影响**:本体管理工具集缺「向已存在类型追加属性」入口,导致 587 个 `data_level` 实例无法被分级引擎接管;现已补齐。
**改动**:
- `PUT /object-types/:api_name` 静默忽略 `properties` 字段已修复,与 `createObjectType` 共用 `upsertObjectTypeProperties`(同名更新元数据,新名新增)。
- MCP 新增 `update_object_type` / `add_object_type_property` 工具。
**设计**:拒绝方案 C(让 `set_object_type_classification` 自动注入未注册属性)——属性注册应是显式动作,不应藏在分类配置里失去审计。
## [1.3.1] - 2026-09-07 访问控制:内置主体可设置自己的 API Key;密钥完全由 DB 管理
修复管理员在「访问控制 → 主体」里编辑 `manager`(或 `connector`)并填入 API Key 时保存失败的问题;同步移除 `.env` 显式密钥,所有主体密钥由 DB(seed 随机值 + UI 管理)唯一管理。
+12
View File
@@ -128,6 +128,18 @@ func (a *app) managerKeySet() bool {
return a.principalKeySet("manager")
}
// anyPrincipalKeySet 报告全库任意主体是否已配置非空 api_key(用于 connectorAuth 在
// 全库无密钥时放行、否则要求带 key 的判定)。修复 issue #8 v2:原 connectorKeySet 仅看
// connector 一个主体,现在需要看任意主体。
func (a *app) anyPrincipalKeySet() bool {
var n int
if err := a.pool.QueryRow(context.Background(),
"SELECT 1 FROM principals WHERE api_key IS NOT NULL AND api_key<>'' LIMIT 1").Scan(&n); err == nil {
return true
}
return false
}
// builtinKey 读取某内置主体当前存于 principals 表的 api_key(用于内部进程调用注入鉴权头)。
func (a *app) builtinKey(name string) string {
var k string
+86 -14
View File
@@ -32,6 +32,8 @@ func (a *app) listPrincipals(c *gin.Context) {
HasAPIKey bool `json:"has_api_key"`
APIKeyHint string `json:"api_key_hint"`
APIKeyCreatedAt string `json:"api_key_created_at,omitempty"`
// 修复 issue #7:clearances 一并回显,否则管理员看不到当前主体的可见级别集。
Clearances []string `json:"clearances"`
}
var out []pRow
for rows.Next() {
@@ -40,7 +42,7 @@ func (a *app) listPrincipals(c *gin.Context) {
var builtin bool
if err := rows.Scan(&p.Name, &p.Description, &builtin, &key); err == nil {
p.IsBuiltin = builtin
row := pRow{Principal: p, HasAPIKey: key != ""}
row := pRow{Principal: p, HasAPIKey: key != "", Clearances: []string{}}
if key != "" {
row.APIKeyHint = maskAPIKey(key)
row.APIKeyCreatedAt = "已绑定"
@@ -48,10 +50,30 @@ func (a *app) listPrincipals(c *gin.Context) {
out = append(out, row)
}
}
// 单独查询所有 clearances(按 principal 分组),避免 N+1
if len(out) > 0 {
clRows, err := a.pool.Query(c, `SELECT principal, marking FROM principal_clearances ORDER BY principal, marking`)
if err == nil {
idx := map[string]int{}
for i, p := range out {
idx[p.Name] = i
}
for clRows.Next() {
var pn, mk string
if clRows.Scan(&pn, &mk) == nil {
if i, ok := idx[pn]; ok {
out[i].Clearances = append(out[i].Clearances, mk)
}
}
}
clRows.Close()
}
}
c.JSON(200, gin.H{"principals": out, "count": len(out)})
}
// getPrincipal 返回单个主体,manager 可拿到完整 api_key(仅展示一次以外不会在 list 中回)
// getPrincipal 返回单个主体,manager 可拿到完整 api_key(仅展示一次以外不会在 list 中回)。
// 修复 issue #7:响应同时回显 clearances 数组,否则前端拿不到主体可见级别集。
func (a *app) getPrincipal(c *gin.Context) {
name := c.Param("name")
var description string
@@ -75,6 +97,20 @@ func (a *app) getPrincipal(c *gin.Context) {
resp["api_key"] = key
resp["api_key_hint"] = maskAPIKey(key)
}
// 拉 clearances(保证非 nil,序列化成 [] 而不是 null)
cls := []string{}
clRows, clErr := a.pool.Query(c,
`SELECT marking FROM principal_clearances WHERE principal=$1 ORDER BY marking`, name)
if clErr == nil {
defer clRows.Close()
for clRows.Next() {
var m string
if clRows.Scan(&m) == nil {
cls = append(cls, m)
}
}
}
resp["clearances"] = cls
c.JSON(200, resp)
}
@@ -101,13 +137,18 @@ type principalInput struct {
}
type principalUpdateInput struct {
Description *string `json:"description"`
APIKey *string `json:"api_key"`
ClearAPIKey bool `json:"clear_api_key"`
GenerateAPIKey bool `json:"generate_api_key"`
Description *string `json:"description"`
APIKey *string `json:"api_key"`
ClearAPIKey bool `json:"clear_api_key"`
GenerateAPIKey bool `json:"generate_api_key"`
// 修复 issue #7:之前 PUT /principals/:name 完全不接受 clearances 字段(用户传时静默忽略),
// 现允许一次性替换主体的 clearance 集(与 PUT /principals/:name/clearances 同义)。
// nil=不动;[]=清空;非空=全量替换(DELETE + INSERT)。
Clearances *[]string `json:"clearances"`
}
// updatePrincipal 修改主体的说明和 api_key
// updatePrincipal 修改主体的说明、api_key、clearances(合并语义)。
// 修复 issue #7:之前 clearances 字段被静默忽略;现支持在同一次 PUT 中同时改 description / api_key / clearances。
func (a *app) updatePrincipal(c *gin.Context) {
name := c.Param("name")
var in principalUpdateInput
@@ -149,20 +190,51 @@ func (a *app) updatePrincipal(c *gin.Context) {
return
}
}
// 修复 issue #7:clearances 字段支持。nil=不动;非空数组(含 [])= 全量替换。
if in.Clearances != nil {
if _, err := tx.Exec(c, `DELETE FROM principal_clearances WHERE principal=$1`, name); err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for _, m := range *in.Clearances {
if m = strings.TrimSpace(m); m != "" {
if _, err := tx.Exec(c,
`INSERT INTO principal_clearances(principal,marking) VALUES($1,$2) ON CONFLICT DO NOTHING`,
name, m); err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
}
}
}
if err := tx.Commit(c); err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
a.InvalidateAuthzCache(name)
// 回读,让前端能立即核对(同时验证上面 writes)
resp := gin.H{"ok": true, "name": name}
if finalKey != "" {
resp["api_key"] = finalKey
resp["api_key_hint"] = maskAPIKey(finalKey)
resp["has_api_key"] = true
} else if in.ClearAPIKey {
resp["has_api_key"] = false
keyTouched := in.ClearAPIKey || in.GenerateAPIKey || (in.APIKey != nil && *in.APIKey != "")
if keyTouched {
// 这次请求确实动了 api_key,按结果回显
if finalKey != "" {
resp["api_key"] = finalKey
resp["api_key_hint"] = maskAPIKey(finalKey)
resp["has_api_key"] = true
} else if in.ClearAPIKey {
resp["has_api_key"] = false
} else {
resp["has_api_key"] = finalKey != ""
}
} else {
resp["has_api_key"] = finalKey != ""
// 未提供 api_key 相关字段:回显 DB 真实状态,避免误导。
// 修复 issue #8 附注:之前此处错误地把 "未传 api_key" 当作 "key 不存在"。
var cur string
_ = a.pool.QueryRow(c, `SELECT COALESCE(api_key,'') FROM principals WHERE name=$1`, name).Scan(&cur)
resp["has_api_key"] = cur != ""
}
if in.Clearances != nil {
resp["clearances"] = *in.Clearances
}
c.JSON(200, resp)
}
+189 -9
View File
@@ -205,6 +205,53 @@ func mcpToolList() []MCPTool {
"required": []string{"api_name", "display_name"},
},
},
{
// 修复 issue #6:MCP 工具集补齐「向已存在对象类型追加/更新属性」入口,
// 解决 587 个 data_level 孤儿(属性已写但 schema 未注册)无法被分类引擎接管的根因。
Name: "update_object_type",
Description: "【写入】更新已存在对象类型的元数据(display_name/icon/group/title_property 等),可一并 upsert properties(合并语义:同名属性更新元数据,新名属性新增;删除走 delete_property)。修复 issue #6 之前 PUT 端点静默忽略 properties 的 bug。",
InputSchema: map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"api_name": map[string]interface{}{"type": "string", "description": "对象类型 api_name(必填,URL 路径)"},
"display_name": map[string]interface{}{"type": "string"},
"description": map[string]interface{}{"type": "string"},
"icon": map[string]interface{}{"type": "string"},
"group": map[string]interface{}{"type": "string"},
"title_property": map[string]interface{}{"type": "string"},
"subtitle_property": map[string]interface{}{"type": "string"},
"color": map[string]interface{}{"type": "string"},
"primary_key": map[string]interface{}{"type": "string"},
"classification_property": map[string]interface{}{"type": "string", "description": "留空=关闭分级;非空=启用并绑定到该属性"},
"classification_levels": map[string]interface{}{"type": "array", "items": map[string]interface{}{"type": "string"}, "description": "分级词汇(有序),如 [L0,L1,L2,L3]"},
"classification_default": map[string]interface{}{"type": "string", "description": "默认级别(必须 ∈ classification_levels)"},
"properties": map[string]interface{}{"type": "array", "description": "可选:upsert 属性数组 [{api_name,display_name,data_type,required,enum_values,description,format,indexable,sensitivity}]"},
},
"required": []string{"api_name"},
},
},
{
// 修复 issue #6 方案 A:MCP 工具集补齐「加一个属性」入口(包装 POST /properties)。
// 与 update_object_type 的内联 properties 等价但更细粒度,适合"只补一个"场景。
Name: "add_object_type_property",
Description: "【写入】向已存在对象类型注册一个新属性(upsert:同名属性按非空字段更新,已存在则覆盖元数据)。用于解决「实例已有 X 属性但 schema 未注册」类缺口(如 587 个 data_level 孤儿)。",
InputSchema: map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"api_name": map[string]interface{}{"type": "string", "description": "对象类型 api_name"},
"property_api_name": map[string]interface{}{"type": "string", "description": "新属性的稳定标识(必填)"},
"display_name": map[string]interface{}{"type": "string", "description": "新属性的中文显示名(必填)"},
"data_type": map[string]interface{}{"type": "string", "description": "string/number/boolean/date/enum/...(默认 string)"},
"required": map[string]interface{}{"type": "boolean"},
"enum_values": map[string]interface{}{"type": "array", "items": map[string]interface{}{"type": "string"}, "description": "enum 约束,如 [L0,L1,L2,L3]"},
"description": map[string]interface{}{"type": "string"},
"format": map[string]interface{}{"type": "string"},
"indexable": map[string]interface{}{"type": "boolean"},
"sensitivity": map[string]interface{}{"type": "string", "description": "字段级敏感度(取自分级词汇)"},
},
"required": []string{"api_name", "property_api_name", "display_name"},
},
},
{
Name: "create_link_type",
Description: "【写入】新建链接类型(关系边),表达两个对象类型之间的关系,如 tds_uses_tee / consumes_ontology。",
@@ -466,6 +513,40 @@ func mcpToolList() []MCPTool {
"required": []string{"id"},
},
},
// 修复 issue #7:MCP 工具集补齐主体维度的读/写入口(之前 36 个工具缺这一片)。
// list_principals / get_principal 只读;set_principal_clearance 是写入(manager 主体)。
{
Name: "list_principals",
Description: "【只读】列出全部主体及其 clearance(分级可见级别)。用于核对「哪些主体能看哪些分级」。",
InputSchema: map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{},
},
},
{
Name: "get_principal",
Description: "【只读】按名称取单个主体(含 description / has_api_key / clearances)。",
InputSchema: map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"name": map[string]interface{}{"type": "string", "description": "主体名"},
},
"required": []string{"name"},
},
},
{
Name: "set_principal_clearance",
Description: "【写入】全量替换主体的 clearance 集(nil 数组=清空)。修复 issue #7 之前 MCP 工具集完全无法配置 clearance 的缺口。可让 connector 也能看 L3 等。",
InputSchema: map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"name": map[string]interface{}{"type": "string", "description": "主体名"},
"clearances": map[string]interface{}{"type": "array", "items": map[string]interface{}{"type": "string"}, "description": "标记集,如 [L0,L1,L2,L3];传 []=清空;alias: markings"},
"markings": map[string]interface{}{"type": "array", "items": map[string]interface{}{"type": "string"}, "description": "alias 同 clearances(与 PUT /principals/:name/clearances 命名一致)"},
},
"required": []string{"name"},
},
},
}
}
@@ -584,7 +665,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
return string(b), false, false
case "get_object_types":
return a.callConn("GET", "/api/v1/connector/object-types", nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/object-types", nil), false, false
case "get_objects_by_type":
typ, _ := args["type"].(string)
@@ -596,12 +677,12 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if v, ok := args["offset"].(float64); ok && v > 0 {
qs += "&offset=" + strconv.Itoa(int(v))
}
return a.callConn("GET", "/api/v1/connector/objects/"+url.PathEscape(typ)+qs, nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/objects/"+url.PathEscape(typ)+qs, nil), false, false
case "get_object":
typ, _ := args["type"].(string)
pk, _ := args["pk"].(string)
return a.callConn("GET", "/api/v1/connector/object/"+url.PathEscape(typ)+"/"+url.PathEscape(pk), nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/object/"+url.PathEscape(typ)+"/"+url.PathEscape(pk), nil), false, false
case "search_ontology":
q, _ := args["q"].(string)
@@ -618,7 +699,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if field != "" {
u += "&field=" + url.QueryEscape(field)
}
return a.callConn("GET", u, nil), false, false
return a.callConn(c, "GET", u, nil), false, false
case "km_list_tree":
t, _ := a.mcpCall("GET", "/api/v1/km/tree", nil, principal)
@@ -676,7 +757,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if typ != "" {
u += "?type=" + url.QueryEscape(typ)
}
return a.callConn("GET", u, nil), false, false
return a.callConn(c, "GET", u, nil), false, false
case "query_related":
typ, _ := args["type"].(string)
@@ -687,7 +768,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
}
filters, _ := args["filters"].(map[string]interface{})
body, _ := json.Marshal(queryInput{Type: typ, Filters: filters, Expand: expand, Limit: limit})
return a.callConn("POST", "/api/v1/connector/query", body), false, false
return a.callConn(c, "POST", "/api/v1/connector/query", body), false, false
case "whoami":
// principal / canWrite 已在函数顶部解析
@@ -728,6 +809,87 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
}
return t, false, false
// 修复 issue #6:之前 MCP 工具集没有"向已存在类型追加属性"的入口,
// 导致 587 个 data_level 孤儿无法被分类引擎接管(方案 A)。
case "update_object_type":
if !canWrite {
return denyWrite()
}
apiName, _ := args["api_name"].(string)
if apiName == "" {
return "参数错误:api_name 必填", false, true
}
body, _ := json.Marshal(args)
t, st := a.callHandler(a.updateObjectType, gin.Params{gin.Param{Key: "name", Value: apiName}}, body, principal)
return t, false, st >= 400
case "add_object_type_property":
if !canWrite {
return denyWrite()
}
apiName, _ := args["api_name"].(string)
propAPIName, _ := args["property_api_name"].(string)
disp, _ := args["display_name"].(string)
if apiName == "" || propAPIName == "" || disp == "" {
return "参数错误:api_name / property_api_name / display_name 必填", false, true
}
body, _ := json.Marshal(map[string]interface{}{
"api_name": propAPIName,
"display_name": disp,
"data_type": optStr(args, "data_type"),
"required": args["required"],
"enum_values": args["enum_values"],
"description": optStr(args, "description"),
"format": optStr(args, "format"),
"indexable": args["indexable"],
"sensitivity": optStr(args, "sensitivity"),
})
t, st := a.callHandler(a.addProperty, gin.Params{gin.Param{Key: "name", Value: apiName}}, body, principal)
return t, false, st >= 400
// 修复 issue #7:MCP 工具集补齐「按主体维度读/写 clearance」。
// 之前 36 个工具没有这俩,导致管理员改不了「connector 看不到 L3」之类配置。
case "list_principals":
t, st := a.callHandler(a.listPrincipals, nil, nil, principal)
return t, false, st >= 400
case "get_principal":
name, _ := args["name"].(string)
if name == "" {
return "参数错误:name 必填", false, true
}
t, st := a.callHandler(a.getPrincipal, gin.Params{gin.Param{Key: "name", Value: name}}, nil, principal)
return t, false, st >= 400
case "set_principal_clearance":
if !canWrite {
return denyWrite()
}
name, _ := args["name"].(string)
if name == "" {
return "参数错误:name 必填", false, true
}
// 接受 clearances / markings 两种命名(与 PUT /principals/:name/clearances 一致用 markings)
var marks []string
if raw, ok := args["clearances"].([]interface{}); ok {
for _, m := range raw {
if s, ok := m.(string); ok {
marks = append(marks, s)
}
}
}
if raw, ok := args["markings"].([]interface{}); ok {
marks = marks[:0]
for _, m := range raw {
if s, ok := m.(string); ok {
marks = append(marks, s)
}
}
}
body, _ := json.Marshal(map[string]interface{}{"markings": marks})
t, st := a.callHandler(a.putClearances, gin.Params{gin.Param{Key: "name", Value: name}}, body, principal)
return t, false, st >= 400
case "create_link_type":
if !canWrite {
return denyWrite()
@@ -954,17 +1116,35 @@ func (a *app) mcpCall(method, path string, body []byte, principal string) (strin
}
// callConn 进程内把请求路由到连接器 handler,复用现有只读逻辑。
func (a *app) callConn(method, path string, body []byte) string {
// 修复 issue #8(v2,按用户「每个主体都有 mcp 访问 key,应该是各自主体身份」反馈):
//
// 透传调用方真实身份(X-API-Key 或 session cookie)给内层请求,
// 让 principalFromRequest 自然解析到对应主体(manager / connector / analyst / ...),
// 读路径的 visibility / classification filter 即按真实身份工作。
//
// 之前 v1 方案(注入 connector key + 手动 X-Principal)本质是「模拟身份」,
// 绕开了主体解析链——仍以 connector 权限过 connectorAuth,再用 X-Principal 覆盖身份,
// 同一份逻辑在两套机制间切来切去。透传更简洁,且与「每个主体各有 key」的设计一致。
//
// connectorAuth 同步放宽:接受任何内置/非内置主体的 key(详见 main.go 注释)。
// principal 参数保留:用于日志/tracing,不参与 auth。
func (a *app) callConn(c *gin.Context, method, path string, body []byte) string {
var reader io.Reader
if body != nil {
reader = bytes.NewReader(body)
}
req := httptest.NewRequest(method, path, reader)
req.Header.Set("Content-Type", "application/json")
// 内部调用连接器 handler:注入 connector 主体的 api_key 以通过 connectorAuth(密钥统一存于 principals 表)。
if k := a.builtinKey("connector"); k != "" {
// 透传调用方真实鉴权:让 principalFromRequest 自然解析到对应主体。
if k := c.GetHeader("X-API-Key"); k != "" {
req.Header.Set("X-API-Key", k)
}
if k := c.Query("key"); k != "" && c.GetHeader("X-API-Key") == "" {
req.Header.Set("X-API-Key", k)
}
if tok, err := c.Cookie(SessionCookieName); err == nil && tok != "" {
req.AddCookie(&http.Cookie{Name: SessionCookieName, Value: tok})
}
w := httptest.NewRecorder()
a.engine.ServeHTTP(w, req)
return w.Body.String()
+70
View File
@@ -2,6 +2,7 @@ package main
import (
"encoding/json"
"fmt"
"strconv"
"github.com/gin-gonic/gin"
@@ -60,6 +61,10 @@ type objectTypeInput struct {
ClassificationProperty string `json:"classification_property"`
ClassificationLevels []string `json:"classification_levels"`
ClassificationDefault string `json:"classification_default"`
// 创建/更新对象类型时一并 upsert 的属性(issue #6)。upsert 语义:同 api_name 已存在则更新元数据,
// 不存在则新增;删除走 DELETE /properties/:id。这样既能一次性创建带属性的类型,
// 也能给已有类型补注册属性(解决"587 个 data_level 孤儿"这类缺口)。
Properties []propertyInput `json:"properties"`
}
func (a *app) createObjectType(c *gin.Context) {
@@ -98,6 +103,13 @@ func (a *app) createObjectType(c *gin.Context) {
c.JSON(409, gin.H{"error": "创建失败(可能 api_name 重复): " + err.Error()})
return
}
// 内联 upsert 属性(如提供)。与 updateObjectType 共用 upsertObjectTypeProperties,保持一致性。
if len(in.Properties) > 0 {
if err := a.upsertObjectTypeProperties(c, id, in.Properties); err != nil {
c.JSON(500, gin.H{"error": "属性写入失败: " + err.Error()})
return
}
}
c.JSON(201, gin.H{"id": id, "api_name": in.APIName})
}
@@ -163,9 +175,67 @@ func (a *app) updateObjectType(c *gin.Context) {
c.JSON(404, gin.H{"error": "对象类型不存在"})
return
}
// 修复 issue #6:之前 properties 字段被静默忽略,导致"已有类型补注册属性"无任何入口。
// 现在 in.Properties 非空时一并 upsert(与 createObjectType 走同一辅助函数,语义一致)。
if len(in.Properties) > 0 {
var oid int64
if err := a.pool.QueryRow(c, `SELECT id FROM object_types WHERE api_name=$1`, name).Scan(&oid); err != nil {
c.JSON(500, gin.H{"error": "取对象类型 id 失败: " + err.Error()})
return
}
if err := a.upsertObjectTypeProperties(c, oid, in.Properties); err != nil {
c.JSON(500, gin.H{"error": "属性写入失败: " + err.Error()})
return
}
}
c.JSON(200, gin.H{"ok": true})
}
// upsertObjectTypeProperties 在指定对象类型上批量 upsert 属性。同 api_name 已存在则按非空字段
// 更新元数据,不存在则新增。删除走 DELETE /properties/:id(保留审计粒度)。
func (a *app) upsertObjectTypeProperties(c *gin.Context, oid int64, props []propertyInput) error {
for _, p := range props {
if p.APIName == "" || p.DisplayName == "" {
return fmt.Errorf("属性 api_name 与 display_name 必填(api_name=%q)", p.APIName)
}
if p.DataType == "" {
p.DataType = "string"
}
enum := "[]"
if len(p.EnumValues) > 0 {
enum = mustJSON(p.EnumValues)
}
defVal := "null"
if p.DefaultValue != nil {
defVal = mustJSON(p.DefaultValue)
}
// upsert: 已存在则按非空字段更新;新建则插入完整记录。
// sensitivity 单独 CASE WHEN 控制(与 updateProperty 保持一致)。
_, err := a.pool.Exec(c,
`INSERT INTO properties(object_type_id,api_name,display_name,data_type,required,enum_values,description,
format,default_value,indexable,vector_index,backing_column,sensitivity)
VALUES($1,$2,$3,$4,$5,$6::jsonb,$7,$8,$9::jsonb,$10,$11,$12,$13)
ON CONFLICT(object_type_id,api_name) DO UPDATE SET
display_name=EXCLUDED.display_name,
data_type=EXCLUDED.data_type,
required=EXCLUDED.required,
enum_values=EXCLUDED.enum_values,
description=EXCLUDED.description,
format=EXCLUDED.format,
default_value=EXCLUDED.default_value,
indexable=EXCLUDED.indexable,
vector_index=EXCLUDED.vector_index,
backing_column=EXCLUDED.backing_column,
sensitivity=EXCLUDED.sensitivity`,
oid, p.APIName, p.DisplayName, p.DataType, p.Required, enum, p.Description,
p.Format, defVal, p.Indexable, p.VectorIndex, p.BackingColumn, p.Sensitivity)
if err != nil {
return err
}
}
return nil
}
func (a *app) deleteObjectType(c *gin.Context) {
name := c.Param("name")
tag, err := a.pool.Exec(c, `DELETE FROM object_types WHERE api_name=$1`, name)
+223
View File
@@ -0,0 +1,223 @@
//go:build integration
package main
import (
"strings"
"testing"
)
// TestIntegration_UpdateObjectType_MergesProperties 修复 issue #6:
// 之前 PUT /object-types/:name 静默忽略 properties 字段,导致「已有类型补注册属性」无入口。
// 验证:properties 数组非空时被 upsert(同名属性更新元数据,新名属性新增)。
func TestIntegration_UpdateObjectType_MergesProperties(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
// 用 setupTestEnv 已建的类型(test_UpdateMergeProp),保证隔离
key := "test_UpdateMergeProp"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": key, "display_name": "测试合并属性"}, h); code != 201 {
t.Fatalf("setup create failed: %d", code)
}
// 1) 第一次 PUT:追加 2 个属性
code, body := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+key,
map[string]any{
"properties": []map[string]any{
{"api_name": "data_level", "display_name": "数据级别",
"data_type": "string", "enum_values": []string{"L0", "L1", "L2", "L3"}},
{"api_name": "owner_team", "display_name": "所属团队", "data_type": "string"},
},
}, h)
if code != 200 {
t.Fatalf("PUT 应 200, got %d body=%v", code, body)
}
// 2) GET object_type 应包含这两个属性
_, got := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
ot := got["object_type"].(map[string]any)
props := ot["properties"].([]any)
apiNames := map[string]bool{}
for _, p := range props {
apiNames[p.(map[string]any)["api_name"].(string)] = true
}
if !apiNames["data_level"] {
t.Errorf("data_level 未注册, props=%v", apiNames)
}
if !apiNames["owner_team"] {
t.Errorf("owner_team 未注册, props=%v", apiNames)
}
// 3) 第二次 PUT:更新 data_level 的 enum + 加新属性(merge 语义,已存在的应被覆盖而非新增)
code, _ = env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+key,
map[string]any{
"properties": []map[string]any{
{"api_name": "data_level", "display_name": "数据级别(已修订)",
"data_type": "string", "enum_values": []string{"L0", "L1", "L2", "L3", "L4"}},
{"api_name": "reviewer", "display_name": "审核人", "data_type": "string"},
},
}, h)
if code != 200 {
t.Fatalf("第二次 PUT 应 200, got %d", code)
}
_, got2 := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
ot2 := got2["object_type"].(map[string]any)
props2 := ot2["properties"].([]any)
var dlProps int
var foundReviewer bool
var dlEnum []any
for _, p := range props2 {
m := p.(map[string]any)
if m["api_name"] == "data_level" {
dlProps++
dlEnum = m["enum_values"].([]any)
}
if m["api_name"] == "reviewer" {
foundReviewer = true
}
}
if dlProps != 1 {
t.Errorf("data_level 应只 1 条(被更新而非新增), got %d", dlProps)
}
if len(dlEnum) != 5 {
t.Errorf("data_level enum 应被覆盖为 5 项, got %d (%v)", len(dlEnum), dlEnum)
}
if !foundReviewer {
t.Errorf("新属性 reviewer 未注册")
}
}
// TestIntegration_AddObjectTypeProperty_MCP 修复 issue #6 方案 A:
// MCP 工具集暴露 add_object_type_property(包装 POST /properties)。
// 验证 MCP 调用真的注册了属性,而不是空跑。
func TestIntegration_AddObjectTypeProperty_MCP(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_AddPropertyMCP"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": key, "display_name": "测试 MCP 加属性"}, h); code != 201 {
t.Fatalf("setup create failed: %d", code)
}
// 通过 MCP 加一个属性
code, body := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "add_object_type_property",
"arguments": map[string]any{
"api_name": key,
"property_api_name": "data_level",
"display_name": "数据级别",
"data_type": "string",
"enum_values": []string{"L0", "L1", "L2", "L3"},
},
},
}, h)
if code != 200 {
t.Fatalf("MCP 应 200, got %d body=%v", code, body)
}
result := body["result"].(map[string]any)
content := result["content"].([]any)
text := content[0].(map[string]any)["text"].(string)
if !strings.Contains(text, `"ok"`) {
t.Errorf("MCP 响应应含 ok, got %s", text)
}
// 验证属性真的注册了
_, got := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
ot := got["object_type"].(map[string]any)
props := ot["properties"].([]any)
var found bool
for _, p := range props {
if p.(map[string]any)["api_name"] == "data_level" {
found = true
break
}
}
if !found {
t.Errorf("data_level 属性未注册, props=%v", props)
}
// MCP 缺 property_api_name 应报错
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "add_object_type_property",
"arguments": map[string]any{
"api_name": key,
"display_name": "缺 api_name",
},
},
}, h)
if code != 200 {
t.Fatalf("MCP 错误响应应 200, got %d", code)
}
r2 := body["result"].(map[string]any)
c2 := r2["content"].([]any)
t2 := c2[0].(map[string]any)["text"].(string)
if !strings.Contains(t2, "property_api_name") {
t.Errorf("MCP 缺 property_api_name 应报错, got %s", t2)
}
}
// TestIntegration_UpdateObjectType_MCP 验证 issue #6 方案 A 的另一半:
// MCP update_object_type 工具可一并 upsert properties。
func TestIntegration_UpdateObjectType_MCP(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_UpdateOTMCP"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": key, "display_name": "测试 MCP update"}, h); code != 201 {
t.Fatalf("setup create failed: %d", code)
}
// MCP 更新 display_name + 追加属性
code, _ := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "update_object_type",
"arguments": map[string]any{
"api_name": key,
"display_name": "测试 MCP update(已修订)",
"properties": []map[string]any{
{"api_name": "data_level", "display_name": "数据级别",
"data_type": "string", "enum_values": []string{"L0", "L1", "L2", "L3"}},
},
},
},
}, h)
if code != 200 {
t.Fatalf("MCP update_object_type 应 200, got %d", code)
}
_, got := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
ot := got["object_type"].(map[string]any)
if ot["display_name"] != "测试 MCP update(已修订)" {
t.Errorf("display_name 未更新, got %v", ot["display_name"])
}
var found bool
for _, p := range ot["properties"].([]any) {
if p.(map[string]any)["api_name"] == "data_level" {
found = true
}
}
if !found {
t.Errorf("data_level 未通过 MCP update_object_type 注册")
}
}
+225
View File
@@ -0,0 +1,225 @@
//go:build integration
package main
import (
"strings"
"testing"
)
// TestIntegration_UpdatePrincipal_Clearances 修复 issue #7:
// 之前 PUT /access/principals/:name 的 clearances 字段被静默忽略,
// 用户找不到任何「编辑主体 clearance」的入口。
// 验证:clearances 数组在 PUT 时一并落库(DELETE + INSERT 全量替换),
// GET /principals/:name 和 listPrincipals 都能回显。
func TestIntegration_UpdatePrincipal_Clearances(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
// 用一个非内置主体(避免污染 manager seed)
key := "test_principal_clearance"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/access/principals/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/access/principals",
map[string]any{"name": key, "description": "测试 clearance 配置"}, h); code != 201 {
t.Fatalf("create principal failed: %d", code)
}
// 1) PUT 设置 clearances
code, body := env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"clearances": []string{"L0", "L1", "L2"}}, h)
if code != 200 {
t.Fatalf("PUT 应 200, got %d body=%v", code, body)
}
if got := body["clearances"]; got == nil {
t.Errorf("响应应回显 clearances, got %v", body)
}
// 2) GET /principals/:name 应回显
_, get := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
cls := get["clearances"].([]any)
if len(cls) != 3 {
t.Errorf("GET 应回 3 项, got %d (%v)", len(cls), cls)
}
// 3) 再次 PUT 全量替换(含 L3)→ 验证替换语义
code, body = env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"clearances": []string{"L0", "L1", "L2", "L3"}}, h)
if code != 200 {
t.Fatalf("PUT 应 200, got %d", code)
}
_, get2 := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
cls2 := get2["clearances"].([]any)
if len(cls2) != 4 {
t.Errorf("替换后应 4 项, got %d (%v)", len(cls2), cls2)
}
// 4) PUT clearances=[] 清空
code, _ = env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"clearances": []string{}}, h)
if code != 200 {
t.Fatalf("PUT 空数组应 200, got %d", code)
}
_, get3 := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
cls3 := get3["clearances"].([]any)
if len(cls3) != 0 {
t.Errorf("清空后应 0 项, got %d (%v)", len(cls3), cls3)
}
// 5) PUT 不带 clearances 字段 → 不动(之前的 clearance 仍空)
code, _ = env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"description": "只改 desc"}, h)
if code != 200 {
t.Fatalf("PUT 不带 clearances 应 200, got %d", code)
}
_, get4 := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
cls4 := get4["clearances"].([]any)
if len(cls4) != 0 {
t.Errorf("未传 clearances 时应保留之前状态(空),got %v", cls4)
}
if get4["description"] != "只改 desc" {
t.Errorf("description 应被更新, got %v", get4["description"])
}
// 6) listPrincipals 应回显该主体的 clearance
_, list := env.httpDo(t, "GET", "/api/v1/access/principals", nil, h)
var found bool
for _, p := range list["principals"].([]any) {
m := p.(map[string]any)
if m["name"] == key {
if clsL := m["clearances"]; clsL == nil {
t.Errorf("listPrincipals 应回显 clearances, got nil")
}
found = true
}
}
if !found {
t.Errorf("listPrincipals 缺新建的 %s", key)
}
}
// TestIntegration_SetPrincipalClearance_MCP 修复 issue #7 方案 A:
// MCP set_principal_clearance 工具能写入;list_principals / get_principal 能读取。
func TestIntegration_SetPrincipalClearance_MCP(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_mcp_clearance"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/access/principals/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/access/principals",
map[string]any{"name": key, "description": "MCP clearance 测试"}, h); code != 201 {
t.Fatalf("create principal failed: %d", code)
}
// 1) MCP set_principal_clearance
code, body := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "set_principal_clearance",
"arguments": map[string]any{
"name": key,
"clearances": []string{"L0", "L1", "L2", "L3"},
},
},
}, h)
if code != 200 {
t.Fatalf("MCP 应 200, got %d body=%v", code, body)
}
// 2) MCP get_principal 应回显
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "get_principal",
"arguments": map[string]any{"name": key},
},
}, h)
if code != 200 {
t.Fatalf("get_principal 应 200, got %d", code)
}
result := body["result"].(map[string]any)
content := result["content"].([]any)
text := content[0].(map[string]any)["text"].(string)
if !strings.Contains(text, `"clearances"`) {
t.Errorf("get_principal 响应应含 clearances, got %s", text)
}
if !strings.Contains(text, `"L3"`) {
t.Errorf("get_principal 响应应含 L3, got %s", text)
}
// 3) MCP list_principals 应包含该主体
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "3", "method": "tools/call",
"params": map[string]any{
"name": "list_principals",
"arguments": map[string]any{},
},
}, h)
if code != 200 {
t.Fatalf("list_principals 应 200, got %d", code)
}
result2 := body["result"].(map[string]any)
content2 := result2["content"].([]any)
text2 := content2[0].(map[string]any)["text"].(string)
if !strings.Contains(text2, key) {
t.Errorf("list_principals 应包含新建 %s, got %s", key, text2)
}
// 4) MCP 缺 name 应报错
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "4", "method": "tools/call",
"params": map[string]any{
"name": "set_principal_clearance",
"arguments": map[string]any{
"clearances": []string{"L0"},
},
},
}, h)
if code != 200 {
t.Fatalf("MCP 错误应 200, got %d", code)
}
r4 := body["result"].(map[string]any)
c4 := r4["content"].([]any)
t4 := c4[0].(map[string]any)["text"].(string)
if !strings.Contains(t4, "name") {
t.Errorf("MCP 缺 name 应报错, got %s", t4)
}
}
// TestIntegration_PutClearances_Rest 顺带验证既有的
// `PUT /principals/:name/clearances` 端点仍然有效(用户不知道有这个端点)。
// 这是 issue #7 的关键发现:端点一直都在,只是用户认知里没有。
func TestIntegration_PutClearances_Rest(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_legacy_clearance_path"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/access/principals/"+key, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/access/principals",
map[string]any{"name": key, "description": "测试旧端点"}, h); code != 201 {
t.Fatalf("create principal failed: %d", code)
}
// 用 PUT /principals/:name/clearances(既有的专用端点)
code, _ := env.httpDo(t, "PUT", "/api/v1/access/principals/"+key+"/clearances",
map[string]any{"markings": []string{"L0", "L2"}}, h)
if code != 200 {
t.Fatalf("PUT clearances 应 200, got %d", code)
}
// GET /principals/:name/clearances(既有只读端点)
_, get := env.httpDo(t, "GET", "/api/v1/access/principals/"+key+"/clearances", nil, h)
cls := get["clearances"].([]any)
if len(cls) != 2 {
t.Errorf("既有专用端点 GET 应 2 项, got %d", len(cls))
}
}
+328
View File
@@ -0,0 +1,328 @@
//go:build integration
package main
import (
"context"
"strings"
"testing"
)
func lenAny(v interface{}) int {
if v == nil {
return 0
}
if sl, ok := v.([]interface{}); ok {
return len(sl)
}
return -1
}
// extractCount 从 MCP 响应里取 count 字段(MCP 工具结果以 JSON 字符串放在 content[0].text)。
// 返回 -1 表示解析失败。
func extractCount(t *testing.T, body map[string]interface{}) int {
t.Helper()
result, ok := body["result"].(map[string]interface{})
if !ok {
return -1
}
content, ok := result["content"].([]interface{})
if !ok || len(content) == 0 {
return -1
}
first, ok := content[0].(map[string]interface{})
if !ok {
return -1
}
text, ok := first["text"].(string)
if !ok {
return -1
}
// 在 text 里找 "count":N
needle := `"count":`
i := strings.Index(text, needle)
if i < 0 {
return -1
}
rest := text[i+len(needle):]
// 跳过空白
for len(rest) > 0 && (rest[0] == ' ' || rest[0] == '\t') {
rest = rest[1:]
}
// 读数字
end := 0
for end < len(rest) && rest[end] >= '0' && rest[end] <= '9' {
end++
}
if end == 0 {
return -1
}
n, err := strconvAtoi(rest[:end])
if err != nil {
return -1
}
return n
}
// strconvAtoi 局部 int 解析(避免 import strconv)
func strconvAtoi(s string) (int, error) {
n := 0
if s == "" {
return 0, errEmpty
}
for _, c := range s {
if c < '0' || c > '9' {
return 0, errNotDigit
}
n = n*10 + int(c-'0')
}
return n, nil
}
var (
errEmpty = simpleErr("empty")
errNotDigit = simpleErr("not digit")
)
type simpleErr string
func (e simpleErr) Error() string { return string(e) }
// seedConnectorForTest 在测试 DB 里塞内置 connector 主体(api_key 已知)。
// setupTestEnv 不调用 seedAccessControlDefaults(避免污染共享测试库),所以每个
// 走 callConn 路径的测试自己负责准备。
func seedConnectorForTest(t *testing.T) string {
t.Helper()
pool, err := initDB(context.Background(), testDSN())
if err != nil {
t.Skipf("无法连接测试 PG: %v", err)
}
defer pool.Close()
const connKey = "test-connector-key-do-not-use-in-prod"
const mgrKey = "test-manager-key-do-not-use-in-prod"
const anaKey = "test-analyst-key-do-not-use-in-prod"
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('connector','test connector',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
connKey)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('manager','test manager',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
mgrKey)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('analyst','test analyst',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
anaKey)
// 注入 clearance:connector L0+L1(与生产 seed 一致);manager L0..L4(豁免前的真实
// clearance 仍写入 DB,classificationCond 对 manager 走 return TRUE 所以不影响;
// analyst 仅 L0(最受限)
// 先 DELETE 再 INSERT,避免上次测试残留的 clearance 留下误配置
_, _ = pool.Exec(context.Background(),
`DELETE FROM principal_clearances WHERE principal IN ('connector','manager','analyst')`)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principal_clearances(principal,marking)
VALUES('connector','L0'),('connector','L1'),
('manager','L0'),('manager','L1'),('manager','L2'),('manager','L3'),('manager','L4'),
('analyst','L0')`)
invalidateClassCache()
authzCache.Range(func(k, _ any) bool { authzCache.Delete(k); return true })
return connKey
}
// TestIntegration_MCPRead_RespectsPrincipal 修复 issue #8:
// 之前 callConn 硬编码 connector 的 api_key,导致所有 MCP 读工具
// (get_objects_by_type / get_object / query_related / search_ontology /
// get_object_types / get_facets)一律以 connector 主体执行——manager 走
// MCP 也只能看到 connector clearance(L0-L2)下的数据,违反 v1.2.0 「manager 不受影响」。
//
// 新行为:callConn 接受 principal 参数,内层请求同时注入
// X-API-Key=<connector>(让 connectorAuth 放行)+ X-Principal=<实际 caller>
// 让 principalFromRequest 走 X-Principal 分支,读 filter 按真实身份工作。
func TestIntegration_MCPRead_RespectsPrincipal(t *testing.T) {
env, _ := setupTestEnv(t)
seedConnectorForTest(t)
hMgr := map[string]string{"X-Principal": "manager"}
// 建一个含 L0/L1/L3 三档的测试类型 + 3 个实例
key := "test_mcp_read_principal"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, hMgr)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{
"api_name": key, "display_name": "测试 MCP 读 principal",
"classification_property": "lvl",
"classification_levels": []string{"L0", "L1", "L3"},
"classification_default": "L0",
}, hMgr); code != 201 {
t.Fatalf("create type failed: %d", code)
}
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties",
map[string]any{"api_name": "lvl", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L1", "L3"}}, hMgr)
for _, c := range []struct{ pk, lvl string }{
{"a_l0", "L0"}, {"a_l1", "L1"}, {"a_l3", "L3"},
} {
code, body := env.httpDo(t, "POST", "/api/v1/objects",
map[string]any{"type": key, "pk": c.pk, "properties": map[string]any{"lvl": c.lvl}},
hMgr)
if code >= 300 {
t.Fatalf("create %s 失败 code=%d body=%v", c.pk, code, body)
}
// 显式写入 object_markings,让 classification 物化到 L3
env.httpDo(t, "PUT", "/api/v1/access/objects/"+key+"/"+c.pk+"/markings",
map[string]any{"markings": []string{c.lvl}}, hMgr)
}
// 3) 通过 MCP /api/v1/mcp 调 get_objects_by_type:connector 身份(X-API-Key: connector_key)应见 2
_, bodyC := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-connector-key-do-not-use-in-prod"})
connectorCount := extractCount(t, bodyC)
if connectorCount != 2 {
t.Errorf("connector 走 MCP get_objects_by_type 应见 2 条(L0+L1), got %d body=%v", connectorCount, bodyC)
}
// 4) manager 身份走 MCP:应见 3(豁免)
_, bodyM := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-manager-key-do-not-use-in-prod"})
managerCount := extractCount(t, bodyM)
if managerCount != 3 {
t.Errorf("manager 走 MCP get_objects_by_type 应见 3 条(含 L3), got %d body=%v", managerCount, bodyM)
}
// 5) analyst 身份(L0 only)走 MCP:应见 1
_, bodyA := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "3", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-analyst-key-do-not-use-in-prod"})
analystCount := extractCount(t, bodyA)
if analystCount != 1 {
t.Errorf("analyst 走 MCP get_objects_by_type 应见 1 条(L0 only), got %d body=%v", analystCount, bodyA)
}
}
// TestIntegration_MCPRead_QueryRelatedPrincipal 通过 MCP /api/v1/mcp 端点
// 验证 callConn 修复:manager 走 query_related 应能见 L3,connector 只能见 L0。
func TestIntegration_MCPRead_QueryRelatedPrincipal(t *testing.T) {
env, _ := setupTestEnv(t)
seedConnectorForTest(t)
hMgr := map[string]string{"X-Principal": "manager"}
key := "test_mcp_query_related"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, hMgr)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{
"api_name": key, "display_name": "MCP query 测试",
"classification_property": "lvl",
"classification_levels": []string{"L0", "L3"},
"classification_default": "L0",
}, hMgr); code != 201 {
t.Fatalf("create type failed: %d", code)
}
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties",
map[string]any{"api_name": "lvl", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L3"}}, hMgr)
for _, c := range []struct{ pk, lvl string }{
{"a_l0", "L0"}, {"a_l3", "L3"},
} {
env.httpDo(t, "POST", "/api/v1/objects",
map[string]any{"type": key, "pk": c.pk, "properties": map[string]any{"lvl": c.lvl}, "via": "test"},
hMgr)
env.httpDo(t, "PUT", "/api/v1/access/objects/"+key+"/"+c.pk+"/markings",
map[string]any{"markings": []string{c.lvl}}, hMgr)
}
// manager 走 query_related
code, body := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "query_related",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-manager-key-do-not-use-in-prod"})
if code != 200 {
t.Fatalf("query_related 应 200, got %d body=%v", code, body)
}
result := body["result"].(map[string]any)
content := result["content"].([]any)
text := content[0].(map[string]any)["text"].(string)
if !strings.Contains(text, `"count":2`) {
t.Errorf("manager query_related 应见 count=2, got %s", text)
}
// connector 走 query_related:应见 1(L0 only)
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "query_related",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-connector-key-do-not-use-in-prod"})
if code != 200 {
t.Fatalf("query_related 应 200, got %d", code)
}
result2 := body["result"].(map[string]any)
content2 := result2["content"].([]any)
text2 := content2[0].(map[string]any)["text"].(string)
if !strings.Contains(text2, `"count":1`) {
t.Errorf("connector query_related 应见 count=1, got %s", text2)
}
}
// TestIntegration_UpdatePrincipal_NotTouchKeyHasAPIEchoTrue 修复 issue #8 附注:
// PUT /access/principals/:name 只传 description 不传 api_key 时,响应 has_api_key
// 应反映 DB 真实状态,而非误报 false。
func TestIntegration_UpdatePrincipal_NotTouchKeyHasAPIEchoTrue(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_not_touch_key"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/access/principals/"+key, nil, h)
})
// 建主体并显式设个 key
if code, _ := env.httpDo(t, "POST", "/api/v1/access/principals",
map[string]any{"name": key, "description": "初始", "generate_api_key": true}, h); code != 201 {
t.Fatalf("create failed: %d", code)
}
// PUT 只改 description,不动 key
code, body := env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"description": "只改 desc"}, h)
if code != 200 {
t.Fatalf("PUT 应 200, got %d", code)
}
if hasKey, _ := body["has_api_key"].(bool); !hasKey {
t.Errorf("PUT 不动 key 时 has_api_key 应保持 true, got body=%v", body)
}
// 再 GET 确认 key 还在
_, get := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
if hasKey, _ := get["has_api_key"].(bool); !hasKey {
t.Errorf("GET 复查 has_api_key 应 true, got %v", get)
}
}
+12 -4
View File
@@ -388,8 +388,15 @@ func (a *app) loginRequired() gin.HandlerFunc {
}
}
// connectorAuth 连接器入口鉴权:connector 主体已配置 api_key 时须在 X-API-Key(或 key 查询参数)
// 携带该 key;未配置 key 的部署则放行(兼容无密钥只读场景)。
// connectorAuth 连接器入口鉴权:key 是「任意主体的有效 api_key」即可放行(修复 issue #8 v2)。
//
// 历史:早期只接受 name='connector' 的 key(连接器入口 = 单一 connector 身份)。
// v2:放宽到任一主体的 key——既然 manager / connector / analyst 等各有 api_key,
// 连接器入口就应当接受调用方的真实身份,让 principalFromRequest 按真实主体解析,
// 读路径的 visibility / classification filter 即按真实身份工作(manager 豁免、
// connector/analyst 按各自 clearance 子集)。
//
// 未提供 key 时:若全库任意主体已配置 key 则要求带(401),全库无 key 则放行(无密钥只读场景)。
func (a *app) connectorAuth() gin.HandlerFunc {
return func(c *gin.Context) {
key := c.GetHeader("X-API-Key")
@@ -397,7 +404,8 @@ func (a *app) connectorAuth() gin.HandlerFunc {
key = c.Query("key")
}
if key == "" {
if a.principalKeySet("connector") {
// 无 key:若任意主体已有 key,则视为必须带 key;否则放行(无密钥只读兼容)
if a.anyPrincipalKeySet() {
c.AbortWithStatusJSON(401, gin.H{"error": "连接器接口需要 X-API-Key"})
return
}
@@ -406,7 +414,7 @@ func (a *app) connectorAuth() gin.HandlerFunc {
}
var name string
if err := a.pool.QueryRow(c,
"SELECT name FROM principals WHERE name='connector' AND api_key=$1", key).Scan(&name); err == nil && name != "" {
"SELECT name FROM principals WHERE api_key=$1", key).Scan(&name); err == nil && name != "" {
c.Next()
return
}