mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-21 13:22:01 +00:00
合入 W2-d 访问密钥与服务账号:服务账号(管理员建、不能登录)与个人访问密钥(管理员开关,缺省关);只存哈希、必设到期、轮换与撤销;按路由白名单放行、封顶在使用者边界(看到的都遮过);发起入口和刷新视图必须带幂等键;视图数据接口 agentlab.viewdata/1;审计、请求记录、钩子收件记录;接口说明;设置里的访问密钥页
This commit is contained in:
@@ -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
@@ -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
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
@@ -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
@@ -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:
|
||||
|
||||
@@ -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()]}
|
||||
|
||||
|
||||
@@ -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}")
|
||||
|
||||
Reference in New Issue
Block a user