Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
refactor(auth): validate identities and clarify API key management (#6752)
MaojiaSheng05c516dc605c
diff --git a/crates/ov_cli/src/commands/admin.rs b/crates/ov_cli/src/commands/admin.rsindex 201a1191f..9022300da 100644--- a/crates/ov_cli/src/commands/admin.rs+++ b/crates/ov_cli/src/commands/admin.rs@@ -467,7 +467,7 @@ fn mask_plaintext_api_keys(value: &mut Value) -> bool {}}-/// Match `openviking/server/api_keys/new.py:mask_api_key` so CLI and API output look the same.+/// Match `openviking/server/api_keys/key_mgr.py:mask_api_key` so CLI and API output look the same.fn mask_api_key(api_key: &str) -> String {let parts: Vec<&str> = api_key.split('.').collect();if api_key.is_empty() || parts.len() != 3 {diff --git a/docs/en/api/08-admin.md b/docs/en/api/08-admin.mdindex 5687b2dd6..81c19faa1 100644--- a/docs/en/api/08-admin.md+++ b/docs/en/api/08-admin.md@@ -1063,7 +1063,7 @@ Create a new workspace with its first admin user.**Code Entry Points:**- `openviking/server/routers/admin.py:create_account` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.create_account` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.create_account` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_create_account` - Python SDK#### 2. Interface and Parameters@@ -1252,7 +1252,7 @@ List all workspaces (ROOT only).**Code Entry Points:**- `openviking/server/routers/admin.py:list_accounts` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.get_accounts` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_accounts` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_accounts` - Python SDK#### 2. Interface and Parameters@@ -1463,7 +1463,7 @@ Register a new user in a workspace.**Code Entry Points:**- `openviking/server/routers/admin.py:register_user` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.register_user` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.register_user` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_register_user` - Python SDK#### 2. Interface and Parameters@@ -1597,7 +1597,7 @@ List active users in a workspace. Users with deletion in progress are omitted.**Code Entry Points:**- `openviking/server/routers/admin.py:list_users` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.get_users` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_users` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_users` - Python SDK#### 2. Interface and Parameters@@ -1829,7 +1829,7 @@ Change an account user's role between USER and ADMIN, including promotion and de**Code Entry Points:**- `openviking/server/routers/admin.py:set_user_role` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.set_role` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.set_role` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_set_role` - Python SDK#### 2. Interface and Parameters@@ -1929,7 +1929,7 @@ Generate and store a user API key. With the default random generation, the old k**Code Entry Points:**- `openviking/server/routers/admin.py:regenerate_key` - HTTP route-- `openviking/server/api_keys/new.py:APIKeyManager.regenerate_key` - Core implementation+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.regenerate_key` - Core implementation- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_regenerate_key` - Python SDK#### 2. Interface and Parametersdiff --git a/docs/zh/api/08-admin.md b/docs/zh/api/08-admin.mdindex 20b2dd5ee..9772dc2da 100644--- a/docs/zh/api/08-admin.md+++ b/docs/zh/api/08-admin.md@@ -921,7 +921,7 @@ User override 并重新继承上述默认值,请 PATCH `{"memory_policy": null**代码入口:**- `openviking/server/routers/admin.py:create_account` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.create_account` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.create_account` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_create_account` - Python SDK#### 2. 接口和参数说明@@ -1108,7 +1108,7 @@ ov --sudo admin create-account acme-private --admin alice \**代码入口:**- `openviking/server/routers/admin.py:list_accounts` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.get_accounts` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_accounts` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_accounts` - Python SDK#### 2. 接口和参数说明@@ -1319,7 +1319,7 @@ ov --sudo task status <task_id>**代码入口:**- `openviking/server/routers/admin.py:register_user` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.register_user` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.register_user` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_register_user` - Python SDK#### 2. 接口和参数说明@@ -1453,7 +1453,7 @@ ov admin register-user acme bob-private --role user \**代码入口:**- `openviking/server/routers/admin.py:list_users` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.get_users` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_users` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_users` - Python SDK#### 2. 接口和参数说明@@ -1684,7 +1684,7 @@ ov --sudo admin remove-user acme bob**代码入口:**- `openviking/server/routers/admin.py:set_user_role` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.set_role` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.set_role` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_set_role` - Python SDK#### 2. 接口和参数说明@@ -1784,7 +1784,7 @@ ov --sudo admin set-role acme bob user**代码入口:**- `openviking/server/routers/admin.py:regenerate_key` - HTTP 路由-- `openviking/server/api_keys/new.py:APIKeyManager.regenerate_key` - 核心实现+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.regenerate_key` - 核心实现- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_regenerate_key` - Python SDK#### 2. 接口和参数说明diff --git a/openviking/server/api_keys/__init__.py b/openviking/server/api_keys/__init__.pyindex 0d39d1c35..fe6b78eae 100644--- a/openviking/server/api_keys/__init__.py+++ b/openviking/server/api_keys/__init__.py@@ -2,16 +2,16 @@# SPDX-License-Identifier: AGPL-3.0"""API key management facade over complete account stores."""-from openviking.server.api_keys.new import (+from openviking.server.api_keys.key_mgr import (APIKeyManager,generate_api_key,- is_new_format_key,+ is_valid_format_key,parse_api_key,)__all__ = ["APIKeyManager",- "is_new_format_key",+ "is_valid_format_key","parse_api_key","generate_api_key",]diff --git a/openviking/server/api_keys/new.py b/openviking/server/api_keys/key_mgr.pysimilarity index 78%rename from openviking/server/api_keys/new.pyrename to openviking/server/api_keys/key_mgr.pyindex f1a10c08d..56ac34c8a 100644--- a/openviking/server/api_keys/new.py+++ b/openviking/server/api_keys/key_mgr.py@@ -6,11 +6,12 @@ import base64import hashlibimport hmacimport secrets-from typing import Optional, Tuple+from typing import Optional, Tuple, TypeGuardfrom typing_extensions import deprecatedfrom openviking.server.account_stores.base import AccountStore+from openviking.server.account_stores.models import DeletionRecord, UserSummaryfrom openviking.server.identity import ResolvedIdentity, Rolefrom openviking_cli.exceptions import (FailedPreconditionError,@@ -32,13 +33,13 @@ def _decode_segment(encoded: str) -> str:return base64.urlsafe_b64decode(encoded.encode("utf-8")).decode("utf-8")-def is_new_format_key(api_key: str) -> bool:+def is_valid_format_key(api_key: str) -> bool:return bool(api_key) and len(api_key.split(".")) == 3def parse_api_key(api_key: str) -> Tuple[str, str, str]:- if not is_new_format_key(api_key):- raise ValueError("Not a new format API key")+ if not is_valid_format_key(api_key):+ raise ValueError("Invalid API key format")account_id, user_id, secret = api_key.split(".")return (_decode_segment(account_id),@@ -62,7 +63,7 @@ def generate_api_key(account_id: str, user_id: str, seed: Optional[str] = None)def mask_api_key(api_key: str) -> str:"""Mask every secret character except the last four; fully hide malformed keys."""- if not is_new_format_key(api_key):+ if not is_valid_format_key(api_key):return "*" * len(api_key)account, user, secret = api_key.split(".")visible_length = 4 if len(secret) > 4 else 0@@ -94,53 +95,56 @@ class APIKeyManager:async def close(self) -> None:await self._store.close()- async def _require_authenticatable_user(self, account_id: str, user_id: str):+ async def _get_registered_identity(+ self, account_id: str, user_id: str+ ) -> ResolvedIdentity | None:+ """Read and validate the registered identity, or return None if missing.++ Freshness follows the store contract; deletion state is checked separately.+ """user = await self.get_user(account_id, user_id)if user is None:- raise UnauthenticatedError("Unknown account or user")- deletion = await self.get_deletion(account_id, user_id)- if deletion is not None:- raise UnauthenticatedError("Invalid API key")- return user+ return None+ try:+ registered_role = Role.parse(user["role"])+ if registered_role == Role.ROOT:+ raise ValueError("ROOT is not an account role")+ except (KeyError, ValueError):+ raise UnauthenticatedError("Registered account identity has an invalid role") from None+ return ResolvedIdentity(role=registered_role, account_id=account_id, user_id=user_id)- async def _require_manageable_user(self, account_id: str, user_id: str):- account = await self.get_account(account_id)- if account is None:- raise NotFoundError(account_id, "account")- if account["status"] != "active":- raise FailedPreconditionError(- "Account deletion is in progress",- details={"task_id": account.get("task_id")},- )- user = await self.get_user_for_management(account_id, user_id)- if user is None:- raise NotFoundError(user_id, "user")- deletion = await self.get_deletion(account_id, user_id)- if deletion is not None:- raise FailedPreconditionError(- "User deletion is in progress",- details={"task_id": deletion.get("task_id")},- )- return user+ @staticmethod+ def _is_authenticatable_identity(+ identity: ResolvedIdentity | None, deletion: DeletionRecord | None+ ) -> TypeGuard[ResolvedIdentity]:+ """Check whether the identity exists and has no account or user deletion record."""+ return identity is not None and deletion is None++ @staticmethod+ def _is_manageable_user(user: UserSummary | None, deletion: DeletionRecord | None) -> bool:+ """Check whether the user exists and has no deletion record.++ The caller must first confirm that the account exists and is active.+ """+ return user is not None and deletion is Noneasync def resolve_identity(self, api_key: str) -> ResolvedIdentity:if self._root_api_key and hmac.compare_digest(api_key, self._root_api_key):return ResolvedIdentity(role=Role.ROOT)account_id, user_id = await self._verify_key(api_key)- user = await self._require_authenticatable_user(account_id, user_id)- return ResolvedIdentity(- role=Role(user["role"]),- account_id=account_id,- user_id=user_id,- )+ identity = await self._get_registered_identity(account_id, user_id)+ deletion = await self.get_deletion(account_id, user_id) if identity is not None else None+ if not self._is_authenticatable_identity(identity, deletion):+ raise UnauthenticatedError("Account identity does not exist or is being deleted")+ return identityasync def _verify_key(self, key: str):- if not is_new_format_key(key):- raise UnauthenticatedError("Invalid API key")+ if not is_valid_format_key(key):+ raise UnauthenticatedError("Invalid API key format")try:account_id, user_id, _ = parse_api_key(key)except (ValueError, UnicodeError):- raise UnauthenticatedError("Invalid API key") from None+ raise UnauthenticatedError("Invalid API key format") from Nonebinding = await self._store.verify_api_key(key, account_id_hint=account_id, user_id_hint=user_id)@@ -183,7 +187,23 @@ class APIKeyManager:async def regenerate_key(self, account_id, user_id, seed=None, *, expected_api_key=None):if not self._issue_user_keys:raise FailedPreconditionError("Personal API keys are disabled in trusted mode")- await self._require_manageable_user(account_id, user_id)+ account = await self.get_account(account_id)+ if account is None:+ raise NotFoundError(account_id, "account")+ if account["status"] != "active":+ raise FailedPreconditionError(+ "Account deletion is in progress",+ details={"task_id": account.get("task_id")},+ )+ user = await self.get_user_for_management(account_id, user_id)+ if user is None:+ raise NotFoundError(user_id, "user")+ deletion = await self.get_deletion(account_id, user_id)+ if not self._is_manageable_user(user, deletion):+ raise FailedPreconditionError(+ "User deletion is in progress",+ details={"task_id": deletion.get("task_id")},+ )key = generate_api_key(account_id, user_id, seed)await self._store.replace_active_user_api_key(account_id, user_id, key, expected_api_key=expected_api_key@@ -191,20 +211,31 @@ class APIKeyManager:return keyasync def get_registered_user_role(self, account_id: str, user_id: str) -> Role | None:- user = await self.get_user(account_id, user_id)- return Role(user["role"]) if user else None+ identity = await self._get_registered_identity(account_id, user_id)+ return identity.role if identity is not None else Noneasync def resolve_oauth_identity(self, account_id: str, user_id: str, role: Role) -> ResolvedIdentity:- user = await self._require_authenticatable_user(account_id, user_id)- if role.rank > Role(user["role"]).rank:+ registered_identity = await self._get_registered_identity(account_id, user_id)+ deletion = (+ await self.get_deletion(account_id, user_id)+ if registered_identity is not None+ else None+ )+ if not self._is_authenticatable_identity(registered_identity, deletion):+ raise UnauthenticatedError("Account identity does not exist or is being deleted")+ try:+ authorized_account_role = Role.parse(role)+ except ValueError:+ raise UnauthenticatedError("Invalid OAuth authorization role") from None+ if not registered_identity.role.allows_token_role(authorized_account_role):raise UnauthenticatedError("OAuth token's embedded role exceeds the user's current role; ""please re-authorize the client.")return ResolvedIdentity(- role=role,+ role=authorized_account_role,account_id=account_id,user_id=user_id,from_oauth=True,@@ -267,9 +298,7 @@ class APIKeyManager:)if name in filters}- page = await self._store.list_users_page(- account_id, **store_filters- )+ page = await self._store.list_users_page(account_id, **store_filters)if not expose_key or not self._issue_user_keys:page["key_count"] = 0for user in page["users"]:diff --git a/openviking/server/app.py b/openviking/server/app.pyindex 7809a6540..a4458f72b 100644--- a/openviking/server/app.py+++ b/openviking/server/app.py@@ -705,11 +705,11 @@ def create_app(or "http://127.0.0.1:1933")- async def _current_role(account_id: str, user_id: str) -> Role:+ async def _registered_account_role(account_id: str, user_id: str) -> Role | None:manager = getattr(app.state, "api_key_manager", None)if manager is None:- return Role.USER- return await manager.get_registered_user_role(account_id, user_id) or Role.USER+ return None+ return await manager.get_registered_user_role(account_id, user_id)_route_provider = OpenVikingOAuthProvider(store=_route_store,@@ -717,7 +717,7 @@ def create_app(access_token_ttl_seconds=ov_cfg.oauth.access_token_ttl_seconds,refresh_token_ttl_seconds=ov_cfg.oauth.refresh_token_ttl_seconds,auth_code_ttl_seconds=ov_cfg.oauth.auth_code_ttl_seconds,- role_resolver=_current_role,+ role_resolver=_registered_account_role,)# Stash the route-time instances; the lifespan replaces these with# initialized copies before the first request lands.diff --git a/openviking/server/auth/__init__.py b/openviking/server/auth/__init__.pyindex ace1ff18c..10f27b3e4 100644--- a/openviking/server/auth/__init__.py+++ b/openviking/server/auth/__init__.py@@ -218,22 +218,28 @@ async def _context_from_signed_token() -> RequestContext:"""Rebuild the request context bound to a consumed upload/download token.- In API-key mode the issuing role is retained only while the account user exists and has- not been downgraded. Other auth modes retain their USER token context.+ In API-key mode the saved authorization role must remain compatible with the+ registered account role. Other auth modes retain their USER token context."""if _auth_mode(request) == AuthMode.API_KEY:manager = get_api_key_manager_or_raise(request)- current_role = await manager.get_registered_user_role(consumed.account_id, consumed.user_id)- if current_role is None:+ registered_account_role = await manager.get_registered_user_role(+ consumed.account_id, consumed.user_id+ )+ if registered_account_role is None:raise UnauthenticatedError("Signed token's user no longer exists")- if Role(consumed.role).rank > current_role.rank:+ try:+ authorized_account_role = Role.parse(consumed.role)+ except ValueError:+ raise UnauthenticatedError("Invalid signed-token authorization role") from None+ if not registered_account_role.allows_token_role(authorized_account_role):raise UnauthenticatedError("Signed token's role exceeds the user's current role; request a new token")return await _build_request_context(request,ResolvedIdentity(- role=consumed.role,+ role=authorized_account_role,account_id=consumed.account_id,user_id=consumed.user_id,from_oauth=consumed.from_oauth,diff --git a/openviking/server/identity.py b/openviking/server/identity.pyindex 25a79c9e3..857f39fb2 100644--- a/openviking/server/identity.py+++ b/openviking/server/identity.py@@ -17,9 +17,12 @@ from openviking_cli.session.user_id import UserIdentifierclass Role(str):"""Role type — supports built-in roles and custom plugin-defined roles.- Built-in roles (root/admin/user) are available as class attributes.+ Built-in roles (root/admin/user/global) are available as class attributes.Custom roles can be registered via ``Role.register(name, rank)``.+ GLOBAL is reserved for account-scoped identities. Its capabilities are+ orthogonal to ADMIN and must not be inferred from rank.+Role comparison is string-based, so ``Role.ROOT == "root"`` and``Role("custom") == "custom"`` both work."""@@ -27,9 +30,9 @@ class Role(str):ROOT = "root"ADMIN = "admin"USER = "user"+ GLOBAL = "global"- # Privilege ranking for role-downgrade detection.- # Higher rank => more privilege.+ # Legacy ranking for token role-downgrade checks, not request authorization._BUILTIN_RANK: dict[str, int] = {USER: 0,ADMIN: 1,@@ -45,12 +48,44 @@ class Role(str):name: Role identifier string.rank: Privilege rank — higher = more privilege."""+ if not isinstance(name, str) or not name:+ raise ValueError("Custom role name must be a non-empty string")+ if name in (cls.ROOT, cls.ADMIN, cls.USER, cls.GLOBAL):+ raise ValueError("Built-in roles cannot be registered as custom roles")+ if not isinstance(rank, int) or isinstance(rank, bool):+ raise ValueError("Custom role rank must be an integer")cls._CUSTOM_RANK[name] = rank+ @classmethod+ def parse(cls, value: object) -> Role:+ """Validate a role before it enters an identity or request context.++ Construction remains string-compatible. Only enabled built-in roles+ and explicitly registered custom roles may become internal identities.+ GLOBAL remains reserved until its authorization rules are implemented.+ """+ if not isinstance(value, str) or (+ value not in (cls.ROOT, cls.ADMIN, cls.USER) and value not in cls._CUSTOM_RANK+ ):+ raise ValueError("Unknown or inactive identity role")+ return cls(value)+@propertydef rank(self) -> int:- """Return the privilege rank for this role."""- return self._BUILTIN_RANK.get(self, self._CUSTOM_RANK.get(self, 0))+ """Return the legacy token rank; unknown roles have no implicit rank."""+ if self in self._BUILTIN_RANK:+ return self._BUILTIN_RANK[self]+ if self in self._CUSTOM_RANK:+ return self._CUSTOM_RANK[self]+ raise ValueError("Role has no legacy token rank")++ def allows_token_role(self, authorized_role: str) -> bool:+ """Check a saved authorization role against this registered role.++ This preserves legacy token compatibility, not operation permissions.+ Neither role is allowed to acquire an implicit rank.+ """+ return self.parse(authorized_role).rank <= self.rankdef __eq__(self, other: object) -> bool:if isinstance(other, Role):@@ -90,6 +125,9 @@ class ResolvedIdentity:# account/user.from_oauth: bool = False+ def __post_init__(self) -> None:+ self.role = Role.parse(self.role)+@dataclassclass RequestContext:@@ -115,6 +153,9 @@ class RequestContext:# the triggering user's resource ACL. Tenant and namespace checks still apply.bypass_acl: bool = False+ def __post_init__(self) -> None:+ self.role = Role.parse(self.role)+@propertydef account_id(self) -> str:return self.user.account_iddiff --git a/openviking/server/oauth/provider.py b/openviking/server/oauth/provider.pyindex 5e6edd82e..180c0571b 100644--- a/openviking/server/oauth/provider.py+++ b/openviking/server/oauth/provider.py@@ -98,7 +98,7 @@ class OpenVikingOAuthProvider(refresh_token_ttl_seconds: int = 30 * 24 * 3600,auth_code_ttl_seconds: int = 300,authorize_page_path: str = DEFAULT_AUTHORIZE_PAGE,- role_resolver: Optional[Callable[[str, str], Role | Awaitable[Role]]] = None,+ role_resolver: Optional[Callable[[str, str], Role | None | Awaitable[Role | None]]] = None,) -> None:self._store = storeself._issuer = issuer.rstrip("/")@@ -106,11 +106,8 @@ class OpenVikingOAuthProvider(self._refresh_ttl = refresh_token_ttl_secondsself._code_ttl = auth_code_ttl_secondsself._authorize_page = authorize_page_path- # Optional callback to look up a user's current role at refresh time.- # When supplied, exchange_refresh_token will reject if the embedded- # role outranks the current role — mirrors the bearer-auth check so- # that `set_role` demotion can't be laundered through token rotation.- # Wired in app.py from the APIKeyManager.+ # Optional account-registry lookup used to validate the saved+ # authorization role at refresh time, matching bearer authentication.self._role_resolver = role_resolver# ---- Clients (DCR) ----@@ -287,22 +284,21 @@ class OpenVikingOAuthProvider(refresh_token: OVRefreshToken,scopes: list[str],) -> OAuthToken:- # Role downgrade gate: if the embedded role outranks the user's- # current role (post-`set_role` demotion), refuse to rotate. Same- # invariant the bearer-auth path enforces; checked here so a- # demoted user can't keep minting fresh access tokens at the old- # privilege level just because they hold a long-lived refresh.+ # Validate the saved authorization role without replacing it with+ # the account-registry role. Registry reads may be cached.if self._role_resolver is not None:try:- token_role = Role(refresh_token.role)+ authorized_account_role = Role.parse(refresh_token.role)resolved = self._role_resolver(refresh_token.account_id, refresh_token.user_id)- current_role = Role(await resolved if inspect.isawaitable(resolved) else resolved)+ registered_account_role = Role.parse(+ await resolved if inspect.isawaitable(resolved) else resolved+ )except Exception as exc:raise TokenError(error="invalid_grant",error_description="Unable to validate current identity; re-authorize the client",) from exc- if token_role.rank > current_role.rank:+ if not registered_account_role.allows_token_role(authorized_account_role):raise TokenError(error="invalid_grant",error_description=(diff --git a/openviking/server/store_assembly.py b/openviking/server/store_assembly.pyindex 9b462f6c5..6ab118482 100644--- a/openviking/server/store_assembly.py+++ b/openviking/server/store_assembly.py@@ -12,7 +12,7 @@ from openviking.storage.viking_fs import VikingFSfrom openviking_cli.exceptions import InvalidArgumentErrorif TYPE_CHECKING:- from openviking.server.api_keys.new import APIKeyManager+ from openviking.server.api_keys.key_mgr import APIKeyManagerdef build_api_key_manager(@@ -29,7 +29,7 @@ def build_api_key_manager(account_store: AccountStore | None = None,) -> APIKeyManager:"""Assemble the API key facade over one complete account store."""- from openviking.server.api_keys.new import APIKeyManager+ from openviking.server.api_keys.key_mgr import APIKeyManagerprovider = account_store_provider.strip().lower()store = build_account_store(diff --git a/tests/integration/test_encryption_integration.py b/tests/integration/test_encryption_integration.pyindex 1091a7eee..9450aa00c 100644--- a/tests/integration/test_encryption_integration.py+++ b/tests/integration/test_encryption_integration.py@@ -17,7 +17,7 @@ import pytest_asynciofrom openviking.crypto.config import bootstrap_encryptionfrom openviking.crypto.encryptor import FileEncryptorfrom openviking.crypto.providers import LocalFileProvider-from openviking.server.api_keys import is_new_format_key+from openviking.server.api_keys import is_valid_format_keyfrom openviking.server.store_assembly import build_api_key_managerfrom openviking.service.core import OpenVikingServicefrom openviking_cli.session.user_id import UserIdentifier@@ -302,7 +302,7 @@ class TestVikingFSEncryptionWithAccounts:# Verify account created successfullyassert user_key is not None- assert is_new_format_key(user_key)+ assert is_valid_format_key(user_key)# RAGFS /local/... paths map to test_data_dir/viking/viking/...# because OpenVikingService path is test_data_dir/viking,@@ -348,7 +348,7 @@ class TestVikingFSEncryptionWithAccounts:# Verify user registered successfullyassert new_user_key is not None- assert is_new_format_key(new_user_key)+ assert is_valid_format_key(new_user_key)# AGFS /local/... paths map to test_data_dir/viking/viking/...agfs_data_root = test_data_dir / "viking" / "viking"@@ -548,7 +548,7 @@ This is a test skill for verifying encryption functionality.admin_user_key = await api_key_manager.create_account(test_account_id, test_admin_user_id)assert admin_user_key is not None- assert is_new_format_key(admin_user_key)+ assert is_valid_format_key(admin_user_key)# 2. Verify list-accounts operationprint("[2] Verify list-accounts operation")@@ -565,7 +565,7 @@ This is a test skill for verifying encryption functionality.print(f"[3] Register test user: {test_user_id}")test_user_key = await api_key_manager.register_user(test_account_id, test_user_id, "user")assert test_user_key is not None- assert is_new_format_key(test_user_key)+ assert is_valid_format_key(test_user_key)# 4. Verify list-users operationprint("[4] Verify list-users operation")@@ -1175,12 +1175,12 @@ class TestAddResourceWithSemanticProcessing:print(f"[1] Create test account: {test_account_id}")admin_user_key = await api_key_manager.create_account(test_account_id, test_admin_user_id)assert admin_user_key is not None- assert is_new_format_key(admin_user_key)+ assert is_valid_format_key(admin_user_key)print(f"[2] Register test user: {test_user_id}")test_user_key = await api_key_manager.register_user(test_account_id, test_user_id, "user")assert test_user_key is not None- assert is_new_format_key(test_user_key)+ assert is_valid_format_key(test_user_key)from openviking.server.identity import RequestContext, Rolefrom openviking_cli.session.user_id import UserIdentifierdiff --git a/tests/integration/test_volcengine_kms_encryption_integration.py b/tests/integration/test_volcengine_kms_encryption_integration.pyindex 02f471940..0dacf45cc 100644--- a/tests/integration/test_volcengine_kms_encryption_integration.py+++ b/tests/integration/test_volcengine_kms_encryption_integration.py@@ -19,7 +19,7 @@ import pytest_asynciofrom openviking.crypto.encryptor import FileEncryptorfrom openviking.crypto.providers import VolcengineKMSProvider-from openviking.server.api_keys import is_new_format_key+from openviking.server.api_keys import is_valid_format_keyfrom openviking.server.store_assembly import build_api_key_managerfrom openviking.service.core import OpenVikingServicefrom openviking_cli.session.user_id import UserIdentifier@@ -359,7 +359,7 @@ class TestVikingFSEncryptionWithVolcengineKMS:user_key = await api_key_manager.create_account(account_id, admin_user_id)assert user_key is not None- assert is_new_format_key(user_key)+ assert is_valid_format_key(user_key)agfs_data_root = test_data_dir / "viking" / "viking"diff --git a/tests/server/test_admin_api.py b/tests/server/test_admin_api.pyindex 9e53e33d9..e6ce3e9c9 100644--- a/tests/server/test_admin_api.py+++ b/tests/server/test_admin_api.py@@ -3087,7 +3087,7 @@ async def test_user_key_mask_handles_malformed_and_short_keys(key, expected):async def test_user_key_mask_reveals_only_the_viewers_own_key():from openviking.server.api_keys import APIKeyManager- from openviking.server.api_keys.new import generate_api_key, mask_api_key+ from openviking.server.api_keys.key_mgr import generate_api_key, mask_api_keyalice_key = generate_api_key("acme", "alice")bob_key = generate_api_key("acme", "bob")diff --git a/tests/server/test_api_key_manager.py b/tests/server/test_api_key_manager.pyindex b7c5b1e4d..a4d036162 100644--- a/tests/server/test_api_key_manager.py+++ b/tests/server/test_api_key_manager.py@@ -69,10 +69,10 @@ async def test_resolve_root_key(manager: APIKeyManager):assert identity.user_id is None[email protected]("key", ["wrong-key", ""])[email protected]("key", ["wrong-key", "", "YWNtZQ.dXNlcg.A"])async def test_resolve_invalid_key_raises(manager: APIKeyManager, key):- """Invalid key should raise UnauthenticatedError."""- with pytest.raises(UnauthenticatedError):+ """Malformed keys should fail authentication with a format error."""+ with pytest.raises(UnauthenticatedError, match="^Invalid API key format$"):await manager.resolve_identity(key)@@ -767,10 +767,10 @@ async def test_user_and_group_persistence_across_reload(manager_service):assert await mgr3.get_group_members(acct, group_id) == []-# ---- New format API Key tests ----+# ---- API Key format tests -----async def test_seeded_new_format_keys_are_predictable(manager: APIKeyManager):+async def test_seeded_api_keys_are_predictable(manager: APIKeyManager):from openviking.server.api_keys import parse_api_keyseed = "client-known-seed"@@ -815,29 +815,78 @@ async def test_seed_must_not_be_empty(manager: APIKeyManager):await manager.create_account(acct, "alice", seed="")-async def test_is_new_format_key_validation():- """Test is_new_format_key correctly identifies key format."""- from openviking.server.api_keys import generate_api_key, is_new_format_key+async def test_is_valid_format_key_validation():+ """Test is_valid_format_key correctly identifies key format."""+ from openviking.server.api_keys import generate_api_key, is_valid_format_key, parse_api_key- # Valid new format+ # Valid API key formatvalid_key = generate_api_key("account", "user")- assert is_new_format_key(valid_key)+ assert is_valid_format_key(valid_key)# Bare single-segment keys are not accepted- assert not is_new_format_key("a" * 64)+ assert not is_valid_format_key("a" * 64)# Empty string- assert not is_new_format_key("")+ assert not is_valid_format_key("")# Wrong number of segments- assert not is_new_format_key("onepart")- assert not is_new_format_key("two.parts")- assert not is_new_format_key("too.many.parts.here")+ assert not is_valid_format_key("onepart")+ assert not is_valid_format_key("two.parts")+ assert not is_valid_format_key("too.many.parts.here")+ with pytest.raises(ValueError, match="^Invalid API key format$"):+ parse_api_key("two.parts")# ---- Registered user role ----[email protected]("delete_account", [False, True])+async def test_registered_identity_remains_readable_but_unusable_during_deletion(+ manager: APIKeyManager, delete_account: bool+):+ acct = _uid()+ await manager.create_account(acct, "alice")+ key = await manager.register_user(acct, "bob", Role.USER)+ assert (await manager.resolve_oauth_identity(acct, "bob", Role.USER)).role == Role.USER++ await manager.begin_deletion(+ acct,+ None if delete_account else "bob",+ task_id="delete-identity",+ owner_account_id=acct,+ owner_user_id="alice",+ )++ assert await manager.get_registered_user_role(acct, "bob") == Role.USER+ with pytest.raises(+ UnauthenticatedError, match="Account identity does not exist or is being deleted"+ ):+ await manager.resolve_oauth_identity(acct, "bob", Role.USER)+ with pytest.raises(UnauthenticatedError, match="Invalid API key"):+ await manager.resolve_identity(key)+ target = "Account" if delete_account else "User"+ with pytest.raises(FailedPreconditionError, match=f"{target} deletion is in progress") as exc:+ await manager.regenerate_key(acct, "bob")+ assert exc.value.details == {"task_id": "delete-identity"}++[email protected]("missing_account", [False, True])+async def test_missing_identity_fails_authentication_and_management_separately(+ manager: APIKeyManager, missing_account: bool+):+ acct = _uid()+ if not missing_account:+ await manager.create_account(acct, "alice")++ assert await manager.get_registered_user_role(acct, "nobody") is None+ with pytest.raises(+ UnauthenticatedError, match="Account identity does not exist or is being deleted"+ ):+ await manager.resolve_oauth_identity(acct, "nobody", Role.USER)+ with pytest.raises(NotFoundError):+ await manager.regenerate_key(acct, "nobody")++async def test_get_registered_user_role_returns_none_when_user_missing(manager: APIKeyManager):acct = _uid()await manager.create_account(acct, "admin_user")diff --git a/tests/server/test_identity_auth.py b/tests/server/test_identity_auth.pyindex 1ee876266..99a8bf2f6 100644--- a/tests/server/test_identity_auth.py+++ b/tests/server/test_identity_auth.py@@ -99,7 +99,9 @@ async def test_key_store_error_and_unknown_identity_fail_closed():manager = APIKeyManager("root", store)request = await make_request(manager)key = generate_api_key("acme", "missing")- with pytest.raises(UnauthenticatedError, match="Unknown"):+ with pytest.raises(+ UnauthenticatedError, match="Account identity does not exist or is being deleted"+ ):await request.app.state.auth_plugin.resolve_identity(request, api_key=key)store.get_user.side_effect = OSError("database offline")with pytest.raises(OSError, match="database offline"):diff --git a/tests/storage/test_semantic_processor_identity.py b/tests/storage/test_semantic_processor_identity.pyindex f68cddc34..5d18bc67f 100644--- a/tests/storage/test_semantic_processor_identity.py+++ b/tests/storage/test_semantic_processor_identity.py@@ -2,11 +2,14 @@# SPDX-License-Identifier: Apache-2.0"""Tests for SemanticProcessor internal context reconstruction."""+from openviking.server.identity import Rolefrom openviking.storage.queuefs.semantic_msg import SemanticMsgfrom openviking.storage.queuefs.semantic_processor import SemanticProcessor-def test_ctx_from_semantic_msg_preserves_identity_and_enables_acl_bypass():+def test_ctx_from_semantic_msg_preserves_identity_and_enables_acl_bypass(monkeypatch):+ monkeypatch.setattr(Role, "_CUSTOM_RANK", Role._CUSTOM_RANK.copy())+ Role.register("reviewer", 1)msg = SemanticMsg(uri="viking://resources/doc",context_type="resource",