合入 W2-d 访问密钥与服务账号:服务账号(管理员建、不能登录)与个人访问密钥(管理员开关,缺省关);只存哈希、必设到期、轮换与撤销;按路由白名单放行、封顶在使用者边界(看到的都遮过);发起入口和刷新视图必须带幂等键;视图数据接口 agentlab.viewdata/1;审计、请求记录、钩子收件记录;接口说明;设置里的访问密钥页

This commit is contained in:
ThearchyHelios
2026-10-16 15:38:33 +08:00
41 changed files with 4221 additions and 124 deletions
+374 -3
View File
@@ -1,9 +1,380 @@
"""访问密钥与服务账号(docs/design/next-round/04-对外集成与触达.md A1–A7)。
"""访问密钥与服务账号(docs/design/next-round/04-对外集成与触达.md A1–A7):建、撤销、轮换密钥,建、停用服务账号,个人
访问密钥的开关,每把密钥最近的请求,接口说明。签发、认人、门禁的规则在 app/auth/keys.py。
main.py 挂登录即可(require_role("user")):本人的个人密钥本人管,服务账号和全部密钥在接口里要管理员。第 2 波 W2-d 填。
main.py 挂登录即可(require_role("user")),接口里再按本人 / 管理员判:
- 管理员看得到服务账号和全部密钥,能给服务账号建密钥、撤销和轮换任何一把;
- 每个人看得到自己的个人访问密钥;管理员打开开关(auth.personal_keys,缺省关)之后才能建;
- 关登录时访问密钥不生效:列表照给(空的,带 login_on=false),建密钥、建服务账号回 409(keys_need_login)。
建、撤销、轮换密钥,建、停用服务账号,开关个人密钥都写审计(同一个事务)。密钥明文只在建、轮换的回包里出现一次。
"""
from __future__ import annotations
from fastapi import APIRouter
import re
from datetime import timedelta
from typing import Any
from fastapi import APIRouter, Depends
from pydantic import BaseModel, Field
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from app.api.coded import CodedHTTPException
from app.api.deps import current_principal
from app.auth import keys
from app.auth.audit import record
from app.db.base import get_session, utcnow
from app.db.models_identity import AccessKey, User
router = APIRouter(prefix="/api/access-keys", tags=["access-keys"])
#: 错误码(403 / 404 / 409 / 422)
KEY_NOT_FOUND = "access_key_not_found"
KEY_FORBIDDEN = "access_key_forbidden"
KEY_INVALID_INPUT = "access_key_invalid"
KEY_NOT_ACTIVE = "access_key_not_active"
PERSONAL_KEYS_OFF = "personal_keys_off"
SERVICE_NOT_FOUND = "service_account_not_found"
SERVICE_INVALID = "service_account_invalid"
SERVICE_TAKEN = "service_account_taken"
_SERVICE_NAME = re.compile(r"^svc-[A-Za-z0-9._-]{1,96}$")
def _iso(value: Any) -> str | None:
return value.isoformat() if value else None
def _need_login() -> None:
if current_principal().mode == "off":
raise CodedHTTPException(409, keys.KEYS_NEED_LOGIN_TEXT, keys.KEYS_NEED_LOGIN)
def _is_admin() -> bool:
principal = current_principal()
return principal.mode != "off" and principal.at_least("admin") and principal.via != "key"
def _require_admin() -> None:
from app.api.deps import ensure_role
ensure_role("admin")
def key_out(row: AccessKey, owner: User | None) -> dict[str, Any]:
"""接口里的一把密钥:没有明文、没有哈希,只有开头一截(prefix)给人认。"""
return {"id": row.id, "name": row.name, "prefix": row.prefix, "scopes": [s for s in row.scopes or []],
"app_ids": list(row.app_ids) if row.app_ids else None,
"owner": {"id": row.owner_user_id, "username": owner.username if owner else None,
"display_name": (owner.display_name or owner.username) if owner else None,
"kind": owner.kind if owner else None},
"personal": owner is None or owner.kind != keys.SERVICE_KIND,
"state": keys.state_of(row, owner),
"expires_at": _iso(row.expires_at), "revoked_at": _iso(row.revoked_at), "revoked_by": row.revoked_by,
"last_used_at": _iso(row.last_used_at), "last_used_ip": row.last_used_ip,
"rotated_from": row.rotated_from, "created_by": row.created_by, "created_at": _iso(row.created_at)}
def service_out(row: User, key_count: int = 0) -> dict[str, Any]:
return {"id": row.id, "username": row.username, "display_name": row.display_name or row.username,
"disabled": row.disabled, "created_by": row.created_by, "created_at": _iso(row.created_at),
"keys": key_count}
async def _owners(session: AsyncSession, rows: list[AccessKey]) -> dict[str, User]:
ids = {r.owner_user_id for r in rows}
if not ids:
return {}
return {u.id: u for u in (await session.execute(select(User).where(User.id.in_(ids)))).scalars()}
# ---------------------------------------------------------------- 开关与概况
@router.get("/settings")
async def get_settings() -> dict[str, Any]:
"""这一页要的几样:开没开登录(关登录时密钥不生效)、个人访问密钥的开关、我能不能建个人密钥、是不是管理员。"""
from app.auth import personal_keys_enabled
principal = current_principal()
login_on = principal.mode != "off"
return {"login_on": login_on, "personal_keys": personal_keys_enabled(), "admin": _is_admin(),
"can_create_personal": login_on and personal_keys_enabled() and bool(principal.user_id)
and principal.via != "key",
"scopes": [*keys.SCOPES], "read_scopes": [*keys.READ_SCOPES], "personal_scopes": [*keys.PERSONAL_SCOPES],
"expires_default_days": keys.EXPIRES_DEFAULT_DAYS, "expires_max_days": keys.EXPIRES_MAX_DAYS}
class SettingsIn(BaseModel):
personal_keys: bool
@router.put("/settings")
async def put_settings(payload: SettingsIn, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""个人访问密钥的开关(只给管理员)。存在登录设置那一行里(auth.personal_keys),和「使用者可以问数据」同一处缓存。
关掉之后建不了个人密钥,已有的个人密钥也不认(401 key_personal_off),重新打开就又能用。"""
from app.auth import PERSONAL_KEYS, SETTING_KEY, load_settings, remember_settings
from app.db.models import Setting
_need_login()
_require_admin()
before = await load_settings(force=True)
value = {**before, PERSONAL_KEYS: payload.personal_keys}
row = await session.get(Setting, SETTING_KEY)
if row is None:
session.add(Setting(key=SETTING_KEY, value=value))
else:
row.value = value
if bool(before.get(PERSONAL_KEYS)) != payload.personal_keys:
await record(session, "auth.personal_keys", "auth", None,
data={"before": bool(before.get(PERSONAL_KEYS)), "after": payload.personal_keys})
await session.commit()
remember_settings(value)
return await get_settings()
@router.get("/reference")
async def reference() -> dict[str, Any]:
"""接口说明(A7):从门禁那张表(auth/keys.KEY_ROUTES)生成,方法、路径、scope、说明、可能的错误码。要登录(main.py 挂的
require_role("user")),不对匿名的人敞开。"""
return keys.reference()
# ---------------------------------------------------------------- 服务账号(只给管理员)
@router.get("/service-accounts")
async def list_service_accounts(session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
_require_admin()
rows = list((await session.execute(select(User).where(User.kind == keys.SERVICE_KIND)
.order_by(User.created_at))).scalars())
counts: dict[str, int] = {}
for owner_id in (await session.execute(select(AccessKey.owner_user_id).where(
AccessKey.owner_user_id.in_([r.id for r in rows] or [""]), AccessKey.revoked_at.is_(None)))).scalars():
counts[owner_id] = counts.get(owner_id, 0) + 1
return {"items": [service_out(r, counts.get(r.id, 0)) for r in rows]}
class ServiceIn(BaseModel):
username: str = Field(min_length=5, max_length=100)
display_name: str | None = Field(default=None, max_length=100)
@router.post("/service-accounts", status_code=201)
async def create_service_account(payload: ServiceIn, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""建一个服务账号:用户名统一 svc- 开头,没有口令、不能登录,角色固定使用者。它就是一个用户——授权、组、名录全部沿用
现有的机制(应用授权里能选它;岗位绑定、选人候选里排除它:服务账号不能被派待办)。"""
_need_login()
_require_admin()
username = payload.username.strip()
if not _SERVICE_NAME.match(username):
raise CodedHTTPException(422, "服务账号的用户名要以 svc- 开头,后面只用字母、数字、点、下划线和短横线",
SERVICE_INVALID, field="username")
if (await session.execute(select(User.id).where(User.username == username))).first():
raise CodedHTTPException(409, f"用户名「{username}」已存在", SERVICE_TAKEN, field="username")
row = User(username=username, display_name=(payload.display_name or "").strip() or username, role="user",
kind=keys.SERVICE_KIND, password_hash=None, created_by=current_principal().username)
session.add(row)
try:
await session.flush()
except IntegrityError as e:
await session.rollback()
raise CodedHTTPException(409, f"用户名「{username}」已存在", SERVICE_TAKEN, field="username") from e
await record(session, "service_account.create", "user", row.id, data={"username": row.username})
await session.commit()
return service_out(row)
class ServicePatch(BaseModel):
display_name: str | None = Field(default=None, max_length=100)
disabled: bool | None = None
async def _service(session: AsyncSession, user_id: str) -> User:
row = await session.get(User, user_id)
if row is None or row.kind != keys.SERVICE_KIND:
raise CodedHTTPException(404, "服务账号不存在", SERVICE_NOT_FOUND)
return row
@router.patch("/service-accounts/{user_id}")
async def update_service_account(user_id: str, payload: ServicePatch,
session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""改显示名、停用 / 启用。停用之后它的密钥全部失效(401 key_owner_disabled),重新启用就又能用(没到期、没撤销的)。"""
_need_login()
_require_admin()
row = await _service(session, user_id)
changes: dict[str, Any] = {}
if payload.display_name is not None and payload.display_name.strip() != row.display_name:
changes["display_name"] = [row.display_name, payload.display_name.strip() or row.username]
row.display_name = payload.display_name.strip() or row.username
if payload.disabled is not None and payload.disabled != row.disabled:
changes["disabled"] = [row.disabled, payload.disabled]
row.disabled = payload.disabled
if changes:
action = ("service_account.disable" if payload.disabled else "service_account.enable") \
if "disabled" in changes else "service_account.update"
await record(session, action, "user", row.id, data={"username": row.username, **changes})
await session.commit()
return service_out(row)
# ---------------------------------------------------------------- 密钥
@router.get("")
async def list_keys(session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""管理员:全部密钥(服务账号的和每个人的个人密钥);别人:自己的个人密钥。关登录时是空的。"""
principal = current_principal()
if principal.mode == "off" or not principal.user_id:
return {"items": []}
query = select(AccessKey).order_by(AccessKey.created_at.desc())
if not _is_admin():
query = query.where(AccessKey.owner_user_id == principal.user_id)
rows = list((await session.execute(query)).scalars())
owners = await _owners(session, rows)
return {"items": [key_out(r, owners.get(r.owner_user_id)) for r in rows]}
class KeyIn(BaseModel):
name: str = Field(min_length=1, max_length=keys.NAME_MAX)
scopes: list[str] = Field(default_factory=lambda: list(keys.READ_SCOPES))
#: 不给(或空)是不限应用
app_ids: list[str] | None = None
expires_in_days: int = Field(default=keys.EXPIRES_DEFAULT_DAYS, ge=1, le=keys.EXPIRES_MAX_DAYS)
#: 给服务账号建(只给管理员);不给是建自己的个人访问密钥
service_account_id: str | None = None
async def _check_input(session: AsyncSession, scopes: list[str], app_ids: list[str] | None, *,
service: bool) -> tuple[list[str], list[str] | None]:
"""scope 只能是认得的那几个(至少一个);服务账号不能勾只给个人密钥的(回复待办)。限定的应用要是在的、共享的应用。"""
from app.db.models_apps import App
picked = list(dict.fromkeys(s for s in scopes))
if not picked or any(s not in keys.SCOPES for s in picked):
raise CodedHTTPException(422, f"权限只能从 {'、'.join(keys.SCOPES)} 里选,至少选一项", KEY_INVALID_INPUT,
field="scopes")
if service and (bad := [s for s in picked if s in keys.PERSONAL_SCOPES]):
raise CodedHTTPException(422, f"服务账号不能被派待办,它的密钥不能有「{'、'.join(bad)}」:外部系统回调请用应用的 signal 钩子",
KEY_INVALID_INPUT, field="scopes")
apps = list(dict.fromkeys(str(a).strip() for a in app_ids or [] if str(a).strip())) or None
if apps is not None:
if len(apps) > keys.APPS_MAX:
raise CodedHTTPException(422, f"一把密钥最多限定 {keys.APPS_MAX} 个应用", KEY_INVALID_INPUT, field="app_ids")
found = {a.id: a for a in (await session.execute(select(App).where(App.id.in_(apps)))).scalars()}
missing = [a for a in apps if a not in found]
personal = [found[a].name for a in apps if a in found and found[a].scope == "personal"]
if missing:
raise CodedHTTPException(422, f"限定的应用不存在:{'、'.join(missing)}", KEY_INVALID_INPUT, field="app_ids")
if personal:
raise CodedHTTPException(422, f"访问密钥不能限定到个人应用:{'、'.join(personal)}", KEY_INVALID_INPUT,
field="app_ids")
return picked, apps
async def _issue(session: AsyncSession, *, owner: User, name: str, scopes: list[str], app_ids: list[str] | None,
days: float, rotated_from: str | None = None) -> tuple[AccessKey, str]:
secret = keys.new_secret()
row = AccessKey(owner_user_id=owner.id, name=name, key_hash=keys.key_hash(secret), prefix=keys.prefix_of(secret),
scopes=scopes, app_ids=app_ids, expires_at=utcnow() + timedelta(days=days),
rotated_from=rotated_from, created_by=current_principal().username)
session.add(row)
await session.flush()
return row, secret
@router.post("", status_code=201)
async def create_key(payload: KeyIn, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""建一把密钥。明文(agl_…)只在这一次的回包里(key);库里只存哈希和开头一截。"""
from app.auth import personal_keys_enabled
_need_login()
principal = current_principal()
if principal.via == "key":
raise CodedHTTPException(403, "不能用访问密钥建访问密钥", KEY_FORBIDDEN)
if payload.service_account_id:
_require_admin()
owner = await _service(session, payload.service_account_id)
if owner.disabled:
raise CodedHTTPException(409, f"服务账号「{owner.username}」已停用,先启用再建密钥", KEY_NOT_ACTIVE)
else:
if not personal_keys_enabled():
raise CodedHTTPException(409, "管理员还没有打开个人访问密钥:系统间集成请让管理员建服务账号的密钥",
PERSONAL_KEYS_OFF)
owner = await session.get(User, principal.user_id) if principal.user_id else None
if owner is None:
raise CodedHTTPException(409, "找不到你的账号,请重新登录", KEY_FORBIDDEN)
scopes, apps = await _check_input(session, payload.scopes, payload.app_ids,
service=owner.kind == keys.SERVICE_KIND)
row, secret = await _issue(session, owner=owner, name=payload.name.strip() or "访问密钥", scopes=scopes,
app_ids=apps, days=payload.expires_in_days)
await record(session, "access_key.create", "access_key", row.id,
data={"name": row.name, "owner": owner.username, "owner_kind": owner.kind, "prefix": row.prefix,
"scopes": scopes, "app_ids": apps, "expires_at": _iso(row.expires_at)})
await session.commit()
return {**key_out(row, owner), "key": secret}
async def _own_or_admin(session: AsyncSession, key_id: str) -> tuple[AccessKey, User | None]:
"""这把密钥能不能由这个人管:管理员能管任何一把;别人只能管自己的。看不到的一律当不存在(404)。"""
_need_login()
principal = current_principal()
if principal.via == "key":
raise CodedHTTPException(403, "不能用访问密钥管理访问密钥", KEY_FORBIDDEN)
row = await session.get(AccessKey, key_id)
if row is None or (not _is_admin() and row.owner_user_id != principal.user_id):
raise CodedHTTPException(404, "访问密钥不存在", KEY_NOT_FOUND)
return row, await session.get(User, row.owner_user_id)
@router.post("/{key_id}/revoke")
async def revoke_key(key_id: str, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""撤销:立刻失效(401 key_revoked),不能恢复。撤销过的再撤销一次照样回成功(不再改时间)。"""
row, owner = await _own_or_admin(session, key_id)
if row.revoked_at is None:
row.revoked_at = utcnow()
row.revoked_by = current_principal().username
await record(session, "access_key.revoke", "access_key", row.id,
data={"name": row.name, "owner": owner.username if owner else None, "prefix": row.prefix})
await session.commit()
return key_out(row, owner)
@router.post("/{key_id}/rotate")
async def rotate_key(key_id: str, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""轮换:签一把新的(名字、权限、限定的应用、有效期长短照旧),旧的 24 小时后到期——换钥匙不用停机。新密钥的明文只在
这一次的回包里(key)。撤销了的、过期了的、已经轮换过的不能再轮换(新建一把)。"""
from app.auth import personal_keys_enabled
row, owner = await _own_or_admin(session, key_id)
state = keys.state_of(row, owner)
if state != "active":
raise CodedHTTPException(409, "这把密钥已撤销、过期或拥有者已停用,不能轮换:请新建一把", KEY_NOT_ACTIVE)
if await session.scalar(select(AccessKey.id).where(AccessKey.rotated_from == row.id).limit(1)):
raise CodedHTTPException(409, "这把密钥已经轮换过:请用轮换出来的那一把", KEY_NOT_ACTIVE)
if owner is None:
raise CodedHTTPException(404, "访问密钥不存在", KEY_NOT_FOUND)
if owner.kind != keys.SERVICE_KIND and not personal_keys_enabled():
raise CodedHTTPException(409, "管理员已关闭个人访问密钥,不能轮换", PERSONAL_KEYS_OFF)
span = keys.aware(row.expires_at) - keys.aware(row.created_at)
days = min(max(span.total_seconds() / 86400, 1.0), float(keys.EXPIRES_MAX_DAYS))
fresh, secret = await _issue(session, owner=owner, name=row.name, scopes=list(row.scopes or []),
app_ids=list(row.app_ids) if row.app_ids else None, days=days, rotated_from=row.id)
grace = utcnow() + keys.ROTATE_GRACE
if keys.aware(row.expires_at) > grace:
row.expires_at = grace
await record(session, "access_key.rotate", "access_key", row.id,
data={"name": row.name, "owner": owner.username, "prefix": row.prefix, "new_key": fresh.id,
"new_prefix": fresh.prefix, "old_expires_at": _iso(row.expires_at)})
await session.commit()
return {**key_out(fresh, owner), "key": secret, "previous": key_out(row, owner)}
@router.get("/{key_id}/requests")
async def key_requests(key_id: str, limit: int = 100, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
"""这把密钥最近的请求(新的在前,最多 100 条):时间、方法、接口(路由模板)、状态码、涉及的运行、来源地址。"""
row, _ = await _own_or_admin(session, key_id)
return {"items": await keys.recent_requests(session, row.id, min(max(limit, 1), 100)),
"retain_days": keys.RETAIN.days}
+98 -9
View File
@@ -256,8 +256,13 @@ async def list_apps(include_archived: bool = False, scope: str | None = None,
query = query.where(App.scope == "personal")
elif scope == "shared":
query = query.where(or_(App.scope == "shared", App.scope.is_(None)))
from app.auth.keys import app_allowed
items = []
for app in (await session.execute(query)).scalars():
if not app_allowed(principal, app):
# 访问密钥(04 细案 A2):个人应用不列,限定了应用的只列那几个
continue
role = await app_role(session, principal, app)
if role is None:
if _sees_stub(principal, app):
@@ -639,8 +644,9 @@ async def grants_problem(session: AsyncSession, items: list[tuple[str, str, str]
wanted.append(key)
if (mode := auth_mode()) != "off":
known = await load_directory(session)
# 服务账号能拿授权(外部系统按授权读应用,docs/design/next-round/04-对外集成与触达.md A1),这里不算对不上
refused = [f"「{ROLE_TEXT[role]}」里的{m.text}" for kind, who, role in wanted
if (m := mismatch(known, mode, kind, who)) is not None and m.blocking]
if (m := mismatch(known, mode, kind, who, allow_service=True)) is not None and m.blocking]
if refused:
return wanted, f"{';'.join(refused)}:授权只能给名录里在用的人和组,请移除或从候选中重新选择"
return wanted, None
@@ -772,6 +778,17 @@ async def delete_hook(app_id: str, name: str, session: AsyncSession = Depends(ge
await session.commit()
@router.get("/{app_id}/hooks/{name}/receipts")
async def hook_receipts(app_id: str, name: str, session: AsyncSession = Depends(get_session),
x_actor: str | None = Header(default=None)) -> dict[str, Any]:
"""这个钩子最近收到的请求(04 细案 A6,要管理权限):最近 100 条的幂等键、状态、时间、发起的实例或解决的待办、被拒的
原因,另给近 1 小时验签失败几次(不落库,只在进程里按钩子数)。还没生成密钥的是空的。"""
from app.process import hooks
app, _ = await _app(session, app_id, _principal(x_actor), "manage")
return await hooks.recent_receipts(session, app.id, name)
# --------------------------------------------------------------------------
# 使用:页面、入口、实例、视图刷新
# --------------------------------------------------------------------------
@@ -830,21 +847,59 @@ class StartIn(BaseModel):
@router.post("/{app_id}/entries/{entry_id}", status_code=201)
async def start(app_id: str, entry_id: str, payload: StartIn, session: AsyncSession = Depends(get_session),
x_actor: str | None = Header(default=None)) -> Any:
"""发起一个实例。表单没通过校验回 422,带 {errors: [{path, code, message}]}。"""
x_actor: str | None = Header(default=None),
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key")) -> Any:
"""发起一个实例。表单没通过校验回 422,带 {errors: [{path, code, message}]}。
用访问密钥发起(docs/design/next-round/04-对外集成与触达.md A4):必须带 Idempotency-Key,同一个键重发交回同一个实例
(duplicate: true),处理到一半服务停了的同一个键能认领回已发起的实例;入口表单里有文件控件的 422
(key_files_unsupported:文件要先在应用里上传,密钥不开上传接口)。"""
from app.apps.entries import EntryRefused, FormRejected, start_entry
from app.apps.resolve import instance_title
from app.auth import keys
from app.engine.launch import LaunchRefused
principal = _principal(x_actor)
app, _ = await _app(session, app_id, principal, "use")
idem = keys.idempotency_of(idempotency_key) if principal.via == "key" else None
async def launch(reclaimed: bool = False) -> dict[str, Any]:
if reclaimed and idem and (run_id := await keys.started_before(principal, idem)):
# 上一次处理到一半服务停了:实例其实已经发起,交回它,不再发起一个
return await replay({"run_id": run_id})
run = await start_entry(app.id, entry_id, payload.values, principal, idempotency_key=idem)
return {"run_id": run.id, "title": instance_title(run)}
async def replay(previous: dict[str, Any]) -> dict[str, Any]:
run = await session.get(Run, previous.get("run_id")) if previous.get("run_id") else None
return {"run_id": previous.get("run_id"), "title": instance_title(run) if run is not None else "",
**({"duplicate": True} if previous.get("duplicate") else {})}
try:
run = await start_entry(app.id, entry_id, payload.values, principal)
if principal.via != "key":
return await launch()
await _refuse_key_files(session, app, entry_id)
return await keys.once(principal, idem, route=f"POST /api/apps/{app.id}/entries/{entry_id}",
request=payload.values, run=launch, replay=replay)
except FormRejected as e:
return JSONResponse(status_code=422, content={"detail": "表单没有通过校验", "code": FORM_INVALID, "errors": e.errors})
except (EntryRefused, LaunchRefused) as e:
raise _view_refused(e) from e
return {"run_id": run.id, "title": instance_title(run)}
async def _refuse_key_files(session: AsyncSession, app: App, entry_id: str) -> None:
"""用访问密钥发起时,入口表单(当前发布版)里有文件控件的拒(422 key_files_unsupported)。发布版、入口不存在的放过去,
由发起照旧报。"""
from app.apps.tree import entry_of, resolve_form
from app.auth import keys
from app.files.store import file_fields
version = await _previous(session, app)
spec = (version.spec or {}) if version is not None else {}
entry = entry_of(spec, entry_id)
if entry is not None and file_fields(resolve_form(spec, entry.get("form"))):
raise CodedHTTPException(422, "这个入口的表单里要传文件,不能用访问密钥发起:请在应用里发起",
keys.KEY_FILES_UNSUPPORTED)
@router.get("/{app_id}/instances")
@@ -899,23 +954,57 @@ class RefreshIn(BaseModel):
@router.post("/{app_id}/views/{view_id}/refresh")
async def refresh_view(app_id: str, view_id: str, payload: RefreshIn, session: AsyncSession = Depends(get_session),
x_actor: str | None = Header(default=None)) -> Any:
"""按需视图:发起一次运行,或者命中缓存、接上同一个参数正在运行的那次。"""
x_actor: str | None = Header(default=None),
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key")) -> Any:
"""按需视图:发起一次运行,或者命中缓存、接上同一个参数正在运行的那次。
用访问密钥刷新(04 细案 A4,集成-I3):同发起实例,必须带 Idempotency-Key,同一个键重发交回同一次运行。刷新本来就按
参数去重(缓存、同一组参数只跑一份),幂等键再管住「上一次失败、缓存被清掉之后重发又发起一次」这种情形。"""
from app.apps.entries import FormRejected
from app.apps.resolve import ViewRefused, run_view
from app.auth import keys
from app.engine.launch import LaunchRefused
principal = _principal(x_actor)
app, _ = await _app(session, app_id, principal, "use")
version = await _current_version(session, app)
try:
async def refresh(_reclaimed: bool = False) -> dict[str, Any]:
# 重新认领时照样走 run_view:上一次已经发起的那次在缓存里,命中它或者接上它,不会再发起一次
run, cached = await run_view(session, app=app, version=version, view_id=view_id, params=payload.params,
principal=principal, actor=actor_of(x_actor))
return {"run_id": run.id, "cached": cached}
async def replay(previous: dict[str, Any]) -> dict[str, Any]:
return {"run_id": previous.get("run_id"), "cached": False, "duplicate": True}
try:
if principal.via != "key":
return await refresh()
return await keys.once(principal, idempotency_key, route=f"POST /api/apps/{app.id}/views/{view_id}/refresh",
request=payload.params, run=refresh, replay=replay)
except FormRejected as e:
return JSONResponse(status_code=422, content={"detail": "参数没有通过校验", "code": FORM_INVALID, "errors": e.errors})
except (ViewRefused, LaunchRefused) as e:
raise _view_refused(e) from e
return {"run_id": run.id, "cached": cached}
@router.get("/{app_id}/views/{view_id}/data")
async def view_data(app_id: str, view_id: str, params: str | None = None, session: AsyncSession = Depends(get_session),
x_actor: str | None = Header(default=None)) -> dict[str, Any]:
"""视图数据(agentlab.viewdata/1,04 细案 A5):按当前发布版解析这个视图取的是哪一次封存的正式运行,交出印章、清单哈希、
口径卡指标的原值和渲染文字(遮罩的 value 为 null)、证据指针。按需视图读 ?params= 这组参数上次算的结果,不发起运行,
没算过的 state=empty。界面和访问密钥都能用;个人应用没有发布版(409)。"""
from app.apps.resolve import ViewRefused, view_data as data_of
principal = _principal(x_actor)
app, role = await _app(session, app_id, principal, "use")
version = await _current_version(session, app)
try:
return await data_of(session, app, version=version, view_id=view_id, params=_params(params),
principal=principal, role=role)
except ViewRefused as e:
raise _view_refused(e) from e
# --------------------------------------------------------------------------
+9 -1
View File
@@ -36,9 +36,12 @@ _OIDC_FIELDS = ("issuer", "client_id", "client_secret", "scopes", "username_clai
def principal_out(p: Principal) -> dict[str, Any]:
from app.auth import personal_keys_enabled
# personal_keys:管理员开没开个人访问密钥(next-round 04 A1),不是管理员的人在设置里据此给不给「访问密钥」一页
return {"mode": p.mode, "username": p.username, "display_name": p.display_name or p.username,
"role": p.role or "user", "groups": list(p.groups), "verified": p.verified,
"user_can_chat": user_can_chat()}
"user_can_chat": user_can_chat(), "personal_keys": personal_keys_enabled()}
async def principal_full(session: AsyncSession, p: Principal) -> dict[str, Any]:
@@ -62,6 +65,11 @@ async def me(x_actor: str | None = Header(default=None), session: AsyncSession =
can_bootstrap = principal.mode == "local" and not await _local_admin_exists(session)
return JSONResponse(status_code=401, content={"detail": "请先登录", "code": AUTH_REQUIRED,
"mode": principal.mode, "can_bootstrap": can_bootstrap})
if principal.via == "key":
# 用访问密钥自省(next-round 04 A4 的 me):另给这把密钥的名字、开头、scope、限定的应用、到期时间
from app.auth.keys import introspect
return {**await principal_full(session, principal), "key": await introspect(session, principal)}
return await principal_full(session, principal)
+12 -2
View File
@@ -3,7 +3,8 @@
登录方式三种:off(默认,今天的行为)、local、oidc。各接口不直接碰请求头或会话,只问这里:
- actor_of(header):记在各「人」列上的名字。关登录时照旧解码 X-Actor(自报署名);开了登录返回认证过的
用户名,请求头一律不看——这样各接口的签名一个都不用改;
- current_principal():完整身份(用户名、角色、组、是否认证过、登录方式),中间件按请求写进 contextvar;
- current_principal():完整身份(用户名、角色、组、是否认证过、登录方式、经什么认出来的),中间件按请求写进 contextvar。
访问密钥认出来的身份(via=key)一律按使用者算,另带这把密钥的 scope 和限定的应用(auth/keys.py);
- require_role(role):挂在 main.py 的 include_router(..., dependencies=[...]) 上的路由级依赖;
- can_read_run / can_read_artifact:运行、工件的读权限(user 角色只能读有授权的应用视图运行、自己参与的实例);
- ensure_role / ensure_can_publish:接口内部按请求内容判定的权限(MCP 的 stdio、受管级发布、版本退役,Q8);
@@ -52,6 +53,15 @@ class Principal:
groups: tuple[str, ...] = field(default_factory=tuple)
verified: bool = False
mode: str = "off"
#: 经什么认出来的(docs/design/next-round/04-对外集成与触达.md A2):off 关登录的自报署名;session 会话 cookie(开登录时
#: 匿名也是这一种:没认出会话);key 访问密钥;hook 入站钩子的签名;share 分享链接(第 3 波)
via: str = "session"
#: 按访问密钥认出来的(via=key):哪一把、叫什么、带哪些 scope、限定在哪些应用(None 是不限应用)。别的认法都是空的。
#: 权限封顶在使用者(A3,auth/keys.principal_for_key):role 一律是 user,这几项只在门禁(auth/keys.key_gate)里再收窄
key_id: str | None = None
key_name: str | None = None
scopes: frozenset[str] = field(default_factory=frozenset)
app_ids: tuple[str, ...] | None = None
def at_least(self, role: str) -> bool:
return ROLE_RANK.get(self.role, 0) >= ROLE_RANK.get(role, 99)
@@ -122,7 +132,7 @@ def current_principal() -> Principal:
principal = _principal.get()
if principal is not None:
return principal
return Principal(username=None, role="admin", verified=False, mode="off")
return Principal(username=None, role="admin", verified=False, mode="off", via="off")
def actor_verified() -> bool:
+13 -2
View File
@@ -24,6 +24,8 @@ from app.db.models import AuditEvent, Group, GroupMember, User
from app.db.models_identity import ROLES
router = APIRouter(prefix="/api", tags=["identity"])
#: 服务账号的用户名开头(auth/keys.SERVICE_PREFIX):这里建的人不能用它,免得和服务账号混在一起
_SERVICE_PREFIX = "svc-"
#: 人和组的名录(GET /api/directory):只读、给搭建者及以上(main.py 挂 require_role("builder")),岗位绑定、应用授权的
#: 选人控件据此给候选、核对填的名字在不在。只有用户名、显示名、是否停用和组名,不含邮箱、角色、登录时间
directory_router = APIRouter(prefix="/api", tags=["identity"])
@@ -40,7 +42,9 @@ def user_out(row: User) -> dict[str, Any]:
return {"id": row.id, "username": row.username, "display_name": row.display_name or row.username,
"email": row.email, "role": row.role, "disabled": row.disabled,
"source": "oidc" if row.oidc_subject else "local", "last_login_at": _iso(row.last_login_at),
"created_at": _iso(row.created_at)}
"created_at": _iso(row.created_at),
# 服务账号(next-round 04 A1)在「设置 → 访问密钥」里建和停用,这里只标出来
"kind": row.kind or "person"}
@router.get("/users")
@@ -65,6 +69,8 @@ def _check_role(role: str) -> None:
@router.post("/users", status_code=201)
async def create_user(payload: UserIn, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
_check_role(payload.role)
if payload.username.lower().startswith(_SERVICE_PREFIX):
raise HTTPException(422, f"{_SERVICE_PREFIX} 开头的用户名留给服务账号:服务账号请在「设置 → 访问密钥」里建")
if payload.password and (problem := password_problem(payload.password)):
raise HTTPException(422, problem)
if (await session.execute(select(User.id).where(User.username == payload.username))).first():
@@ -101,6 +107,9 @@ async def update_user(user_id: str, payload: UserPatch, session: AsyncSession =
row = await session.get(User, user_id)
if row is None:
raise HTTPException(404, "用户不存在")
if row.kind == "service" and ((payload.role is not None and payload.role != row.role) or payload.password):
# 服务账号角色固定使用者、没有口令、不能登录(访问密钥一律按使用者算,next-round 04 A1、A3)
raise HTTPException(409, "服务账号的角色固定是使用者,也不能设密码:它只持有访问密钥,在「设置 → 访问密钥」里管理")
changes: dict[str, Any] = {}
if payload.role is not None and payload.role != row.role:
_check_role(payload.role)
@@ -222,7 +231,9 @@ async def directory(session: AsyncSession = Depends(get_session)) -> dict[str, A
from app.auth.directory import load_directory
known = await load_directory(session)
return {"users": [{"username": u.username, "display_name": u.display_name, "disabled": u.disabled}
# 服务账号另标 service:岗位绑定、改派不能选它(不能被派待办),应用授权能选
return {"users": [{"username": u.username, "display_name": u.display_name, "disabled": u.disabled,
**({"service": True} if u.service else {})}
for u in known.users.values()],
"groups": [{"name": g.name, "label": g.label} for g in known.groups.values()]}
+33 -3
View File
@@ -62,13 +62,43 @@ async def list_tasks(
statuses = None if status == "all" else _csv(status) or ["pending"]
items = await task_service.list_tasks(principal, assigned=assigned, statuses=statuses, app_id=app_id,
run_id=run_id, limit=limit)
return {"items": items}
return {"items": await _for_key(principal, items)}
async def _for_key(principal: Any, items: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""访问密钥(04 细案 A2):个人应用、只给拥有者的运行(个人应用的刷新、蓝图试运行)里的待办不列;限定了应用的只列那几个
应用里的(不属于应用的待办也不列)。不是密钥认出来的原样交回。"""
if getattr(principal, "via", None) != "key":
return items
from sqlalchemy import select
from app.auth.access import PRIVATE_ORIGINS
from app.db.base import SessionLocal
from app.db.models import App, Run
app_ids = {i.get("app_id") for i in items if i.get("app_id")}
run_ids = {i.get("run_id") for i in items if i.get("run_id")}
async with SessionLocal() as session:
personal = set((await session.execute(select(App.id).where(App.id.in_(app_ids or {""}),
App.scope == "personal"))).scalars())
private = set((await session.execute(select(Run.id).where(
Run.id.in_(run_ids or {""}), Run.origin_kind.in_(PRIVATE_ORIGINS)))).scalars())
return [i for i in items if i.get("app_id") not in personal and i.get("run_id") not in private
and (principal.app_ids is None or i.get("app_id") in principal.app_ids)]
@router.get("/count")
async def count_tasks(mine: int = 1, x_actor: str | None = Header(default=None)) -> dict[str, Any]:
"""导航徽标:派给我的、待处理的待办数,按来源分开(apps:应用里的;other:画布、定时任务的审批);latest 是最新一条的开出时间。"""
return await task_service.count(principal_of(x_actor))
"""导航徽标:派给我的、待处理的待办数,按来源分开(apps:应用里的;other:画布、定时任务的审批);latest 是最新一条的开出时间。
访问密钥按它碰得到的那几条数(同列表的 _for_key),不另写一份计数的口径。"""
principal = principal_of(x_actor)
if getattr(principal, "via", None) != "key":
return await task_service.count(principal)
items = await _for_key(principal, await task_service.list_tasks(principal, statuses=["pending"], limit=500))
stamps = [i.get("created_at") for i in items if i.get("created_at")]
apps = sum(1 for i in items if i.get("app_id"))
return {"mine": len(items), "apps": apps, "other": len(items) - apps, "latest": max(stamps) if stamps else None}
@router.get("/{task_id}")